614 lines
18 KiB
TypeScript
614 lines
18 KiB
TypeScript
import * as plugins from './plugins.js';
|
|
import * as paths from './paths.js';
|
|
import * as interfaces from '../dist_ts_interfaces/index.js';
|
|
import { DevToolsController } from './controllers/controller.devtools.js';
|
|
import { TypedRequestController } from './controllers/controller.typedrequest.js';
|
|
import { BuiltInRoutesController } from './controllers/controller.builtin.js';
|
|
|
|
export interface IServerOptions {
|
|
/**
|
|
* serve a particular directory
|
|
*/
|
|
serveDir?: string;
|
|
|
|
/**
|
|
* inject a reload script that takes care of live reloading
|
|
*/
|
|
injectReload?: boolean;
|
|
|
|
/**
|
|
* watch the serve directory?
|
|
*/
|
|
watch?: boolean;
|
|
|
|
cors: boolean;
|
|
|
|
/**
|
|
* a default answer given in case there is no other handler.
|
|
*/
|
|
defaultAnswer?: () => Promise<string>;
|
|
|
|
/**
|
|
* will try to reroute traffic to an ssl connection using headers
|
|
*/
|
|
forceSsl?: boolean;
|
|
|
|
/**
|
|
* allows serving manifests
|
|
*/
|
|
manifest?: plugins.smartmanifest.ISmartManifestConstructorOptions;
|
|
|
|
/**
|
|
* the port to listen on
|
|
*/
|
|
port?: number | string;
|
|
publicKey?: string;
|
|
privateKey?: string;
|
|
sitemap?: boolean;
|
|
feed?: boolean;
|
|
robots?: boolean;
|
|
domain?: string;
|
|
|
|
/**
|
|
* convey information about the app being served
|
|
*/
|
|
appVersion?: string;
|
|
feedMetadata?: plugins.smartfeed.IFeedOptions;
|
|
articleGetterFunction?: () => Promise<plugins.tsclass.content.IArticle[]>;
|
|
blockWaybackMachine?: boolean;
|
|
}
|
|
|
|
export type THttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'ALL';
|
|
|
|
export interface IRouteHandler {
|
|
(request: Request): Promise<Response | null>;
|
|
}
|
|
|
|
export interface IRegisteredRoute {
|
|
pattern: string;
|
|
regex: RegExp;
|
|
paramNames: string[];
|
|
method: THttpMethod;
|
|
handler: IRouteHandler;
|
|
}
|
|
|
|
export class TypedServer {
|
|
// instance
|
|
public options: IServerOptions;
|
|
public smartServe: plugins.smartserve.SmartServe;
|
|
public smartwatchInstance: plugins.smartwatch.Smartwatch;
|
|
public serveDirHashSubject = new plugins.smartrx.rxjs.ReplaySubject<string>(1);
|
|
public serveHash: string = '000000';
|
|
public typedsocket: plugins.typedsocket.TypedSocket;
|
|
public typedrouter = new plugins.typedrequest.TypedRouter();
|
|
|
|
// Sitemap helper
|
|
private sitemapHelper: SitemapHelper;
|
|
private smartmanifestInstance: plugins.smartmanifest.SmartManifest;
|
|
|
|
// Decorated controllers
|
|
private devToolsController: DevToolsController;
|
|
private typedRequestController: TypedRequestController;
|
|
private builtInRoutesController: BuiltInRoutesController;
|
|
|
|
// File server for static files
|
|
private fileServer: plugins.smartserve.FileServer;
|
|
|
|
// Custom route handlers (for addRoute API)
|
|
private customRoutes: IRegisteredRoute[] = [];
|
|
|
|
public lastReload: number = Date.now();
|
|
public ended = false;
|
|
|
|
constructor(optionsArg: IServerOptions) {
|
|
const standardOptions: IServerOptions = {
|
|
port: 3000,
|
|
injectReload: false,
|
|
serveDir: null,
|
|
watch: false,
|
|
cors: true,
|
|
};
|
|
this.options = {
|
|
...standardOptions,
|
|
...optionsArg,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Access sitemap URLs (for adding/replacing)
|
|
*/
|
|
public get sitemap() {
|
|
return this.sitemapHelper;
|
|
}
|
|
|
|
/**
|
|
* Add a custom route handler
|
|
* Supports Express-style path patterns like '/path/:param' and '/path/*splat'
|
|
* @param path - The route path pattern
|
|
* @param method - HTTP method (GET, POST, PUT, DELETE, PATCH, ALL)
|
|
* @param handler - Async function that receives Request and returns Response or null
|
|
*/
|
|
public addRoute(path: string, method: THttpMethod, handler: IRouteHandler): void {
|
|
// Convert Express-style path to regex
|
|
const paramNames: string[] = [];
|
|
let regexPattern = path
|
|
// Handle named parameters :param
|
|
.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, paramName) => {
|
|
paramNames.push(paramName);
|
|
return '([^/]+)';
|
|
})
|
|
// Handle wildcard *splat (matches everything including slashes)
|
|
.replace(/\*([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, paramName) => {
|
|
paramNames.push(paramName);
|
|
return '(.*)';
|
|
});
|
|
|
|
// Ensure exact match
|
|
regexPattern = `^${regexPattern}$`;
|
|
|
|
this.customRoutes.push({
|
|
pattern: path,
|
|
regex: new RegExp(regexPattern),
|
|
paramNames,
|
|
method,
|
|
handler,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Parse route parameters from a path using a registered route
|
|
*/
|
|
private parseRouteParams(
|
|
route: IRegisteredRoute,
|
|
pathname: string
|
|
): Record<string, string> | null {
|
|
const match = pathname.match(route.regex);
|
|
if (!match) return null;
|
|
|
|
const params: Record<string, string> = {};
|
|
route.paramNames.forEach((name, index) => {
|
|
params[name] = match[index + 1];
|
|
});
|
|
return params;
|
|
}
|
|
|
|
/**
|
|
* inits and starts the server
|
|
*/
|
|
public async start() {
|
|
// Validate essential configuration before starting
|
|
if (this.options.injectReload && !this.options.serveDir) {
|
|
throw new Error(
|
|
'You set to inject the reload script without a serve dir. This is not supported at the moment.'
|
|
);
|
|
}
|
|
|
|
const port =
|
|
typeof this.options.port === 'string'
|
|
? parseInt(this.options.port, 10)
|
|
: this.options.port || 3000;
|
|
|
|
// Initialize optional helpers
|
|
if (this.options.sitemap) {
|
|
this.sitemapHelper = new SitemapHelper(this.options.domain);
|
|
}
|
|
if (this.options.manifest) {
|
|
this.smartmanifestInstance = new plugins.smartmanifest.SmartManifest(this.options.manifest);
|
|
}
|
|
|
|
// Initialize file server for static files
|
|
if (this.options.serveDir) {
|
|
this.fileServer = new plugins.smartserve.FileServer({
|
|
root: this.options.serveDir,
|
|
index: ['index.html'],
|
|
etag: true,
|
|
});
|
|
}
|
|
|
|
// Initialize decorated controllers
|
|
if (this.options.injectReload) {
|
|
this.devToolsController = new DevToolsController({
|
|
getLastReload: () => this.lastReload,
|
|
getEnded: () => this.ended,
|
|
});
|
|
}
|
|
|
|
this.typedRequestController = new TypedRequestController(this.typedrouter);
|
|
|
|
this.builtInRoutesController = new BuiltInRoutesController({
|
|
domain: this.options.domain,
|
|
robots: this.options.robots,
|
|
manifest: this.smartmanifestInstance,
|
|
sitemap: this.options.sitemap,
|
|
feed: this.options.feed,
|
|
appVersion: this.options.appVersion,
|
|
feedMetadata: this.options.feedMetadata,
|
|
articleGetterFunction: this.options.articleGetterFunction,
|
|
blockWaybackMachine: this.options.blockWaybackMachine,
|
|
getSitemapUrls: () => this.sitemapHelper?.urls || [],
|
|
});
|
|
|
|
// Register controllers with SmartServe's ControllerRegistry
|
|
if (this.options.injectReload) {
|
|
plugins.smartserve.ControllerRegistry.registerInstance(this.devToolsController);
|
|
}
|
|
plugins.smartserve.ControllerRegistry.registerInstance(this.typedRequestController);
|
|
plugins.smartserve.ControllerRegistry.registerInstance(this.builtInRoutesController);
|
|
|
|
// Compile routes for fast matching
|
|
plugins.smartserve.ControllerRegistry.compileRoutes();
|
|
|
|
// Build SmartServe options
|
|
const smartServeOptions: plugins.smartserve.ISmartServeOptions = {
|
|
port,
|
|
hostname: '0.0.0.0',
|
|
tls:
|
|
this.options.privateKey && this.options.publicKey
|
|
? {
|
|
key: this.options.privateKey,
|
|
cert: this.options.publicKey,
|
|
}
|
|
: undefined,
|
|
websocket: {
|
|
typedRouter: this.typedrouter,
|
|
onConnectionOpen: (peer) => {
|
|
peer.tags.add('typedserver_frontend');
|
|
console.log(`WebSocket connected: ${peer.id}`);
|
|
},
|
|
onConnectionClose: (peer) => {
|
|
console.log(`WebSocket disconnected: ${peer.id}`);
|
|
},
|
|
},
|
|
};
|
|
|
|
this.smartServe = new plugins.smartserve.SmartServe(smartServeOptions);
|
|
|
|
// Set up custom request handler that integrates with ControllerRegistry
|
|
this.smartServe.setHandler(async (request: Request): Promise<Response> => {
|
|
return this.handleRequest(request);
|
|
});
|
|
|
|
// Setup file watching
|
|
if (this.options.watch && this.options.serveDir) {
|
|
try {
|
|
this.smartwatchInstance = new plugins.smartwatch.Smartwatch([this.options.serveDir]);
|
|
await this.smartwatchInstance.start();
|
|
(await this.smartwatchInstance.getObservableFor('change')).subscribe(async () => {
|
|
await this.createServeDirHash();
|
|
this.reload();
|
|
});
|
|
await this.createServeDirHash();
|
|
} catch (error) {
|
|
console.error('Failed to initialize file watching:', error);
|
|
}
|
|
}
|
|
|
|
// Start the server
|
|
await this.smartServe.start();
|
|
console.log(`TypedServer listening on port ${port}`);
|
|
|
|
// Setup TypedSocket using SmartServe integration
|
|
try {
|
|
this.typedsocket = plugins.typedsocket.TypedSocket.fromSmartServe(
|
|
this.smartServe,
|
|
this.typedrouter
|
|
);
|
|
|
|
// Setup typedrouter handlers
|
|
this.typedrouter.addTypedHandler<interfaces.IReq_GetLatestServerChangeTime>(
|
|
new plugins.typedrequest.TypedHandler('getLatestServerChangeTime', async () => {
|
|
return {
|
|
time: this.lastReload,
|
|
};
|
|
})
|
|
);
|
|
} catch (error) {
|
|
console.error('Failed to initialize TypedSocket:', error);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create an IRequestContext from a Request
|
|
*/
|
|
private async createContext(
|
|
request: Request,
|
|
params: Record<string, string>
|
|
): Promise<plugins.smartserve.IRequestContext> {
|
|
const url = new URL(request.url);
|
|
const method = request.method.toUpperCase() as THttpMethod;
|
|
|
|
// Parse query params
|
|
const query: Record<string, string> = {};
|
|
url.searchParams.forEach((value, key) => {
|
|
query[key] = value;
|
|
});
|
|
|
|
// Parse body
|
|
let body: unknown = undefined;
|
|
const contentType = request.headers.get('content-type');
|
|
if (contentType?.includes('application/json')) {
|
|
try {
|
|
body = await request.clone().json();
|
|
} catch {
|
|
body = {};
|
|
}
|
|
}
|
|
|
|
return {
|
|
request,
|
|
body,
|
|
params,
|
|
query,
|
|
headers: request.headers,
|
|
path: url.pathname,
|
|
method,
|
|
url,
|
|
runtime: 'node' as const,
|
|
state: {},
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Main request handler - routes to appropriate sub-handlers
|
|
*/
|
|
private async handleRequest(request: Request): Promise<Response> {
|
|
const url = new URL(request.url);
|
|
const path = url.pathname;
|
|
const method = request.method.toUpperCase() as THttpMethod;
|
|
|
|
// First, try to match via ControllerRegistry (decorated routes)
|
|
const match = plugins.smartserve.ControllerRegistry.matchRoute(path, method);
|
|
if (match) {
|
|
try {
|
|
const context = await this.createContext(request, match.params);
|
|
const result = await match.route.handler(context);
|
|
|
|
// Handle Response or convert to Response
|
|
if (result instanceof Response) {
|
|
return result;
|
|
}
|
|
return new Response(JSON.stringify(result), {
|
|
status: 200,
|
|
headers: { 'Content-Type': 'application/json' },
|
|
});
|
|
} catch (error) {
|
|
if (error instanceof plugins.smartserve.RouteNotFoundError) {
|
|
// Route explicitly threw "not found", continue to other handlers
|
|
} else {
|
|
console.error('Controller error:', error);
|
|
return new Response('Internal Server Error', { status: 500 });
|
|
}
|
|
}
|
|
}
|
|
|
|
// Custom routes (registered via addRoute)
|
|
for (const route of this.customRoutes) {
|
|
if (route.method === 'ALL' || route.method === method) {
|
|
const params = this.parseRouteParams(route, path);
|
|
if (params !== null) {
|
|
(request as any).params = params;
|
|
const response = await route.handler(request);
|
|
if (response) return response;
|
|
}
|
|
}
|
|
}
|
|
|
|
// HTML injection for reload (if enabled)
|
|
if (this.options.injectReload && this.options.serveDir) {
|
|
const response = await this.handleHtmlWithInjection(request);
|
|
if (response) return response;
|
|
}
|
|
|
|
// Try static file serving
|
|
if (this.fileServer && (method === 'GET' || method === 'HEAD')) {
|
|
try {
|
|
const staticResponse = await this.fileServer.serve(request);
|
|
if (staticResponse) {
|
|
return staticResponse;
|
|
}
|
|
} catch (error) {
|
|
// Fall through to 404
|
|
}
|
|
}
|
|
|
|
// Default answer for root
|
|
if (path === '/' && method === 'GET' && this.options.defaultAnswer) {
|
|
const html = await this.options.defaultAnswer();
|
|
return new Response(html, {
|
|
status: 200,
|
|
headers: { 'Content-Type': 'text/html' },
|
|
});
|
|
}
|
|
|
|
// Not found
|
|
return new Response('Not Found', { status: 404 });
|
|
}
|
|
|
|
/**
|
|
* Handle HTML files with reload script injection
|
|
*/
|
|
private async handleHtmlWithInjection(request: Request): Promise<Response | null> {
|
|
const url = new URL(request.url);
|
|
const requestPath = url.pathname;
|
|
|
|
// Check if this is a request for an HTML file or root
|
|
if (requestPath === '/' || requestPath.endsWith('.html') || !requestPath.includes('.')) {
|
|
try {
|
|
let filePath = requestPath === '/' ? 'index.html' : requestPath.slice(1);
|
|
if (!filePath.endsWith('.html') && !filePath.includes('.')) {
|
|
filePath = plugins.path.join(filePath, 'index.html');
|
|
}
|
|
|
|
const fullPath = plugins.path.join(this.options.serveDir, filePath);
|
|
|
|
// Security check
|
|
if (!fullPath.startsWith(this.options.serveDir)) {
|
|
return new Response('Forbidden', { status: 403 });
|
|
}
|
|
|
|
let fileContent = (await plugins.fsInstance
|
|
.file(fullPath)
|
|
.encoding('utf8')
|
|
.read()) as string;
|
|
|
|
// Inject reload script
|
|
if (fileContent.includes('<head>')) {
|
|
const injection = `<head>
|
|
<!-- injected by @apiglobal/typedserver start -->
|
|
<script async defer type="module" src="/typedserver/devtools"></script>
|
|
<script>
|
|
globalThis.typedserver = {
|
|
lastReload: ${this.lastReload},
|
|
versionInfo: ${JSON.stringify({}, null, 2)},
|
|
}
|
|
</script>
|
|
<!-- injected by @apiglobal/typedserver stop -->
|
|
`;
|
|
fileContent = fileContent.replace('<head>', injection);
|
|
console.log('injected typedserver script.');
|
|
}
|
|
|
|
return new Response(fileContent, {
|
|
status: 200,
|
|
headers: {
|
|
'Content-Type': 'text/html; charset=utf-8',
|
|
'Cache-Control': 'no-cache, no-store, must-revalidate',
|
|
Pragma: 'no-cache',
|
|
Expires: '0',
|
|
appHash: this.serveHash,
|
|
},
|
|
});
|
|
} catch (error) {
|
|
// Fall through to default handling
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* reloads the page
|
|
*/
|
|
public async reload() {
|
|
this.lastReload = Date.now();
|
|
if (!this.typedsocket) {
|
|
console.warn('TypedSocket not initialized, skipping client notifications');
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const connections = await this.typedsocket.findAllTargetConnectionsByTag(
|
|
'typedserver_frontend'
|
|
);
|
|
for (const connection of connections) {
|
|
const pushTime =
|
|
this.typedsocket.createTypedRequest<interfaces.IReq_PushLatestServerChangeTime>(
|
|
'pushLatestServerChangeTime',
|
|
connection
|
|
);
|
|
pushTime.fire({
|
|
time: this.lastReload,
|
|
});
|
|
}
|
|
} catch (error) {
|
|
console.error('Failed to notify clients about reload:', error);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Stops the server and cleans up resources
|
|
*/
|
|
public async stop(): Promise<void> {
|
|
this.ended = true;
|
|
|
|
const stopWithErrorHandling = async (
|
|
stopFn: () => Promise<unknown>,
|
|
componentName: string
|
|
): Promise<void> => {
|
|
try {
|
|
await stopFn();
|
|
} catch (err) {
|
|
console.error(`Error stopping ${componentName}:`, err);
|
|
}
|
|
};
|
|
|
|
const tasks: Promise<void>[] = [];
|
|
|
|
// Stop SmartServe
|
|
if (this.smartServe) {
|
|
tasks.push(stopWithErrorHandling(() => this.smartServe.stop(), 'SmartServe'));
|
|
}
|
|
|
|
// Stop TypedSocket (in SmartServe mode, this is a no-op but good for cleanup)
|
|
if (this.typedsocket) {
|
|
tasks.push(stopWithErrorHandling(() => this.typedsocket.stop(), 'TypedSocket'));
|
|
}
|
|
|
|
// Stop file watcher
|
|
if (this.smartwatchInstance) {
|
|
tasks.push(stopWithErrorHandling(() => this.smartwatchInstance.stop(), 'file watcher'));
|
|
}
|
|
|
|
await Promise.all(tasks);
|
|
}
|
|
|
|
/**
|
|
* Calculates a hash of the served directory for cache busting
|
|
*/
|
|
public async createServeDirHash() {
|
|
try {
|
|
const serveDirHash = await plugins.fsInstance
|
|
.directory(this.options.serveDir)
|
|
.recursive()
|
|
.treeHash();
|
|
this.serveHash = serveDirHash.slice(0, 12);
|
|
console.log('Current ServeDir hash: ' + this.serveHash);
|
|
this.serveDirHashSubject.next(this.serveHash);
|
|
} catch (error) {
|
|
console.error('Failed to create serve directory hash:', error);
|
|
const fallbackHash = Date.now().toString(16).slice(-6);
|
|
this.serveHash = fallbackHash;
|
|
console.log('Using fallback hash: ' + fallbackHash);
|
|
this.serveDirHashSubject.next(fallbackHash);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// Helper Classes
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Sitemap helper class
|
|
*/
|
|
class SitemapHelper {
|
|
private smartSitemap = new plugins.smartsitemap.SmartSitemap();
|
|
public urls: plugins.smartsitemap.IUrlInfo[] = [];
|
|
|
|
constructor(domain?: string) {
|
|
if (domain) {
|
|
this.urls.push({
|
|
url: `https://${domain}/`,
|
|
timestamp: Date.now(),
|
|
frequency: 'daily',
|
|
});
|
|
}
|
|
}
|
|
|
|
async createSitemap(): Promise<string> {
|
|
return this.smartSitemap.createSitemapFromUrlInfoArray(this.urls);
|
|
}
|
|
|
|
async createSitemapNews(articles: plugins.tsclass.content.IArticle[]): Promise<string> {
|
|
return this.smartSitemap.createSitemapNewsFromArticleArray(articles);
|
|
}
|
|
|
|
replaceUrls(urlsArg: plugins.smartsitemap.IUrlInfo[]) {
|
|
this.urls = urlsArg;
|
|
}
|
|
|
|
addUrls(urlsArg: plugins.smartsitemap.IUrlInfo[]) {
|
|
this.urls = this.urls.concat(urlsArg);
|
|
}
|
|
}
|