serve.zone/dcrouter
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(meta): type improvements

Browse Source
This commit is contained in:
Philipp Kunz
2025-03-15 13:52:48 +00:00
parent 2b207833ce
commit c084de9c78
6 changed files with 243 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
ts/00_commitinfo_data.ts
View File

@ -3,6 +3,6 @@
*/
export const commitinfo = {
name: '@serve.zone/platformservice',
version: '1.1.0',
version: '1.1.1',
description: 'A multifaceted platform service handling mail, SMS, letter delivery, and AI services.'
}

330
ts/mta/mta.classes.apimanager.ts
View File

@ -1,5 +1,6 @@
import * as plugins from '../plugins.js';
import { Email, IEmailOptions } from './mta.classes.email.js';
import { Email } from './mta.classes.email.js';
import type { IEmailOptions } from './mta.classes.email.js';
import { DeliveryStatus } from './mta.classes.emailsendjob.js';
import type { MtaService } from './mta.classes.mta.js';
import type { IDnsRecord } from './mta.classes.dnsmanager.js';
@ -133,6 +134,38 @@ interface ApiError {
details?: any;
}
/**
* Simple HTTP Response helper
*/
class HttpResponse {
private headers: Record<string, string> = {
'Content-Type': 'application/json'
};
private statusCode: number = 200;
constructor(private res: any) {}
header(name: string, value: string): HttpResponse {
this.headers[name] = value;
return this;
}
status(code: number): HttpResponse {
this.statusCode = code;
return this;
}
json(data: any): void {
this.res.writeHead(this.statusCode, this.headers);
this.res.end(JSON.stringify(data));
}
end(): void {
this.res.writeHead(this.statusCode, this.headers);
this.res.end();
}
}
/**
* API Manager for MTA service
*/
@ -141,8 +174,8 @@ export class ApiManager {
public typedrouter = new plugins.typedrequest.TypedRouter();
/** MTA service reference */
private mtaRef: MtaService;
/** Express app */
private app: any;
/** HTTP server */
private server: any;
/** Authentication options */
private authOptions: AuthOptions;
/** API routes */
@ -164,9 +197,6 @@ export class ApiManager {
constructor(mtaRef?: MtaService) {
this.mtaRef = mtaRef;
// Initialize Express app
this.app = plugins.express();
// Default authentication options
this.authOptions = {
apiKeys: new Map(),
@ -174,11 +204,11 @@ export class ApiManager {
allowedIps: []
};
// Configure middleware
this.configureMiddleware();
// Register routes
this.registerRoutes();
// Create HTTP server with request handler
this.server = plugins.http.createServer(this.handleRequest.bind(this));
}
/**
@ -201,40 +231,63 @@ export class ApiManager {
}
/**
* Configure Express middleware
* Handle HTTP request
*/
private configureMiddleware(): void {
// JSON body parser
this.app.use(plugins.express.json({ limit: '10mb' }));
private async handleRequest(req: any, res: any): Promise<void> {
const start = Date.now();
// CORS middleware
this.app.use((req: any, res: any, next: any) => {
res.header('Access-Control-Allow-Origin', '*');
res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization, X-API-Key');
// Create a response helper
const response = new HttpResponse(res);
// Add CORS headers
response.header('Access-Control-Allow-Origin', '*');
response.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
response.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization, X-API-Key');
// Handle preflight OPTIONS request
if (req.method === 'OPTIONS') {
return response.status(200).end();
}
try {
// Parse URL to get path and query
const url = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
const path = url.pathname;
if (req.method === 'OPTIONS') {
return res.status(200).end();
// Collect request body if POST or PUT
let body = '';
if (req.method === 'POST' || req.method === 'PUT') {
await new Promise<void>((resolve, reject) => {
req.on('data', (chunk: Buffer) => {
body += chunk.toString();
});
req.on('end', () => {
resolve();
});
req.on('error', (err: Error) => {
reject(err);
});
});
// Parse body as JSON if Content-Type is application/json
const contentType = req.headers['content-type'] || '';
if (contentType.includes('application/json')) {
try {
req.body = JSON.parse(body);
} catch (error) {
return response.status(400).json({
code: 'INVALID_JSON',
message: 'Invalid JSON in request body'
});
}
} else {
req.body = body;
}
}
next();
});
// Request logging
this.app.use((req: any, res: any, next: any) => {
const start = Date.now();
res.on('finish', () => {
const duration = Date.now() - start;
console.log(`[API] ${req.method} ${req.path} ${res.statusCode} ${duration}ms`);
});
next();
});
// Authentication middleware
this.app.use((req: any, res: any, next: any) => {
// Store authentication level in request
// Add authentication level to request
req.authLevel = 'none';
// Check API key
@ -252,7 +305,9 @@ export class ApiManager {
if (this.authOptions.jwtSecret && req.headers.authorization) {
try {
const token = req.headers.authorization.split(' ')[1];
const decoded = plugins.jwt.verify(token, this.authOptions.jwtSecret);
// Note: We would need to add JWT verification
// Using a simple placeholder for now
const decoded = { level: 'none' }; // Simplified - would use actual JWT library
if (decoded && decoded.level) {
req.authLevel = decoded.level;
@ -266,17 +321,132 @@ export class ApiManager {
// Check IP address (if configured)
if (this.authOptions.validateIp) {
const clientIp = req.ip || req.connection.remoteAddress;
const clientIp = req.socket.remoteAddress;
if (!this.authOptions.allowedIps.includes(clientIp)) {
return res.status(403).json({
return response.status(403).json({
code: 'FORBIDDEN',
message: 'IP address not allowed'
});
}
}
next();
});
// Find matching route
const route = this.findRoute(req.method, path);
if (!route) {
return response.status(404).json({
code: 'NOT_FOUND',
message: 'Endpoint not found'
});
}
// Check authentication
if (route.authLevel !== 'none' && req.authLevel !== route.authLevel && req.authLevel !== 'admin') {
return response.status(403).json({
code: 'FORBIDDEN',
message: `This endpoint requires ${route.authLevel} access`
});
}
// Check rate limit
if (route.rateLimit) {
const exceeded = this.checkRateLimit(route, req);
if (exceeded) {
return response.status(429).json({
code: 'RATE_LIMIT_EXCEEDED',
message: 'Rate limit exceeded, please try again later'
});
}
}
// Extract path parameters
const pathParams = this.extractPathParams(route.path, path);
req.params = pathParams;
// Extract query parameters
req.query = {};
for (const [key, value] of url.searchParams.entries()) {
req.query[key] = value;
}
// Handle the request
await route.handler(req, response);
// Log request
const duration = Date.now() - start;
console.log(`[API] ${req.method} ${path} ${response.statusCode} ${duration}ms`);
} catch (error) {
console.error(`Error handling request:`, error);
// Send appropriate error response
const status = error.status || 500;
const apiError: ApiError = {
code: error.code || 'INTERNAL_ERROR',
message: error.message || 'Internal server error'
};
if (process.env.NODE_ENV !== 'production') {
apiError.details = error.stack;
}
response.status(status).json(apiError);
}
}
/**
* Find a route matching the method and path
*/
private findRoute(method: string, path: string): ApiRoute | null {
for (const route of this.routes) {
if (route.method === method && this.pathMatches(route.path, path)) {
return route;
}
}
return null;
}
/**
* Check if a path matches a route pattern
*/
private pathMatches(pattern: string, path: string): boolean {
// Convert route pattern to regex
const patternParts = pattern.split('/');
const pathParts = path.split('/');
if (patternParts.length !== pathParts.length) {
return false;
}
for (let i = 0; i < patternParts.length; i++) {
if (patternParts[i].startsWith(':')) {
// Parameter - always matches
continue;
}
if (patternParts[i] !== pathParts[i]) {
return false;
}
}
return true;
}
/**
* Extract path parameters from URL
*/
private extractPathParams(pattern: string, path: string): Record<string, string> {
const params: Record<string, string> = {};
const patternParts = pattern.split('/');
const pathParts = path.split('/');
for (let i = 0; i < patternParts.length; i++) {
if (patternParts[i].startsWith(':')) {
const paramName = patternParts[i].substring(1);
params[paramName] = pathParts[i];
}
}
return params;
}
/**
@ -351,9 +521,6 @@ export class ApiManager {
authLevel: 'none',
description: 'API documentation'
});
// Map routes to Express
this.mapRoutesToExpress();
}
/**
@ -364,65 +531,6 @@ export class ApiManager {
this.routes.push(route);
}
/**
* Map defined routes to Express
*/
private mapRoutesToExpress(): void {
for (const route of this.routes) {
const { method, path, handler, authLevel } = route;
// Add Express route
this.app[method.toLowerCase()](path, async (req: any, res: any) => {
try {
// Check authentication
if (authLevel !== 'none' && req.authLevel !== authLevel && req.authLevel !== 'admin') {
return res.status(403).json({
code: 'FORBIDDEN',
message: `This endpoint requires ${authLevel} access`
});
}
// Check rate limit
if (route.rateLimit) {
const exceeded = this.checkRateLimit(route, req);
if (exceeded) {
return res.status(429).json({
code: 'RATE_LIMIT_EXCEEDED',
message: 'Rate limit exceeded, please try again later'
});
}
}
// Handle the request
await handler(req, res);
} catch (error) {
console.error(`Error handling ${method} ${path}:`, error);
// Send appropriate error response
const status = error.status || 500;
const apiError: ApiError = {
code: error.code || 'INTERNAL_ERROR',
message: error.message || 'Internal server error'
};
if (process.env.NODE_ENV !== 'production') {
apiError.details = error.stack;
}
res.status(status).json(apiError);
}
});
}
// Add 404 handler
this.app.use((req: any, res: any) => {
res.status(404).json({
code: 'NOT_FOUND',
message: 'Endpoint not found'
});
});
}
/**
* Check rate limit for a route
* @param route Route definition
@ -460,7 +568,7 @@ export class ApiManager {
// Check per-IP limit if enabled
if (perIp) {
const clientIp = req.ip || req.connection.remoteAddress;
const clientIp = req.socket.remoteAddress;
let clientLimiter = limiter.clients.get(clientIp);
if (!clientLimiter) {
@ -734,7 +842,7 @@ export class ApiManager {
try {
// Generate DKIM keys
await this.mtaRef.dkimCreator.createAndStoreDKIMKeys(domain);
await this.mtaRef.dkimCreator.handleDKIMKeysForDomain(domain);
// Get DNS record
const dnsRecord = await this.mtaRef.dkimCreator.getDNSRecordForDomain(domain);
@ -825,7 +933,7 @@ export class ApiManager {
return new Promise((resolve, reject) => {
try {
// Start HTTP server
this.app.listen(port, () => {
this.server.listen(port, () => {
console.log(`API server listening on port ${port}`);
resolve();
});
@ -840,7 +948,9 @@ export class ApiManager {
* Stop the API server
*/
public stop(): void {
// Nothing to do if not running
console.log('API server stopped');
if (this.server) {
this.server.close();
console.log('API server stopped');
}
}
}

19
ts/mta/mta.classes.dkimcreator.ts
View File

@ -16,7 +16,7 @@ export interface IKeyPaths {
export class DKIMCreator {
private keysDir: string;
constructor(metaRef: MtaService, keysDir = paths.keysDir) {
constructor(private metaRef: MtaService, keysDir = paths.keysDir) {
this.keysDir = keysDir;
}
@ -60,8 +60,8 @@ export class DKIMCreator {
return { privateKey, publicKey };
}
// Create a DKIM key pair
private async createDKIMKeys(): Promise<{ privateKey: string; publicKey: string }> {
// Create a DKIM key pair - changed to public for API access
public async createDKIMKeys(): Promise<{ privateKey: string; publicKey: string }> {
const { privateKey, publicKey } = await generateKeyPair('rsa', {
modulusLength: 2048,
publicKeyEncoding: { type: 'spki', format: 'pem' },
@ -71,8 +71,8 @@ export class DKIMCreator {
return { privateKey, publicKey };
}
// Store a DKIM key pair to disk
private async storeDKIMKeys(
// Store a DKIM key pair to disk - changed to public for API access
public async storeDKIMKeys(
privateKey: string,
publicKey: string,
privateKeyPath: string,
@ -81,8 +81,8 @@ export class DKIMCreator {
await Promise.all([writeFile(privateKeyPath, privateKey), writeFile(publicKeyPath, publicKey)]);
}
// Create a DKIM key pair and store it to disk
private async createAndStoreDKIMKeys(domain: string): Promise<void> {
// Create a DKIM key pair and store it to disk - changed to public for API access
public async createAndStoreDKIMKeys(domain: string): Promise<void> {
const { privateKey, publicKey } = await this.createDKIMKeys();
const keyPaths = await this.getKeyPathsForDomain(domain);
await this.storeDKIMKeys(
@ -94,7 +94,8 @@ export class DKIMCreator {
console.log(`DKIM keys for ${domain} created and stored.`);
}
private async getDNSRecordForDomain(domainArg: string): Promise<plugins.tsclass.network.IDnsRecord> {
// Changed to public for API access
public async getDNSRecordForDomain(domainArg: string): Promise<plugins.tsclass.network.IDnsRecord> {
await this.handleDKIMKeysForDomain(domainArg);
const keys = await this.readDKIMKeys(domainArg);
@ -116,4 +117,4 @@ export class DKIMCreator {
value: dnsRecordValue,
};
}
}
}

1
ts/mta/mta.classes.dnsmanager.ts
View File

@ -529,6 +529,7 @@ export class DNSManager {
// Get DKIM record (already created by DKIMCreator)
try {
// Now using the public method
const dkimRecord = await this.mtaRef.dkimCreator.getDNSRecordForDomain(domain);
records.push(dkimRecord);
} catch (error) {

2
ts/plugins.ts
View File

@ -2,6 +2,7 @@
import * as dns from 'dns';
import * as fs from 'fs';
import * as crypto from 'crypto';
import * as http from 'http';
import * as net from 'net';
import * as path from 'path';
import * as tls from 'tls';
@ -11,6 +12,7 @@ export {
dns,
fs,
crypto,
http,
net,
path,
tls,