@zintrust/core 0.1.39 → 0.1.41

package/src/proxy/sqlserver/SqlServerProxyServer.js

@@ -0,0 +1,168 @@
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorHandler } from '../ErrorHandler.js';
+import { createProxyServer } from '../ProxyServer.js';
+import { resolveBaseConfig, resolveBaseSigningConfig, verifyRequestSignature, } from '../ProxyServerUtils.js';
+import { RequestValidator } from '../RequestValidator.js';
+import { validateSqlPayload } from '../SqlPayloadValidator.js';
+const resolveDatabaseConfig = (overrides = {}) => {
+    const dbHost = overrides.dbHost ?? Env.get('DB_HOST_MSSQL', Env.get('DB_HOST', '127.0.0.1'));
+    const dbPort = overrides.dbPort ?? Env.getInt('DB_PORT_MSSQL', 1433);
+    const dbName = overrides.dbName ?? Env.get('DB_DATABASE_MSSQL', 'zintrust');
+    const dbUser = overrides.dbUser ?? Env.get('DB_USERNAME_MSSQL', 'sa');
+    const dbPass = overrides.dbPass ?? Env.get('DB_PASSWORD_MSSQL', '');
+    const connectionLimit = overrides.connectionLimit ?? Env.getInt('SQLSERVER_PROXY_POOL_LIMIT', 10);
+    return { dbHost, dbPort, dbName, dbUser, dbPass, connectionLimit };
+};
+const resolveConfig = (overrides = {}) => {
+    const proxyConfig = resolveBaseConfig(overrides, 'SQLSERVER');
+    const dbConfig = resolveDatabaseConfig(overrides);
+    const signingConfig = resolveBaseSigningConfig(overrides, 'SQLSERVER');
+    const poolConfig = {
+        server: dbConfig.dbHost,
+        port: dbConfig.dbPort,
+        database: dbConfig.dbName,
+        user: dbConfig.dbUser,
+        password: dbConfig.dbPass,
+        pool: {
+            max: dbConfig.connectionLimit,
+            min: 0,
+            idleTimeoutMillis: 30000,
+        },
+        options: {
+            encrypt: false,
+            trustServerCertificate: true,
+        },
+    };
+    return {
+        host: proxyConfig.host,
+        port: proxyConfig.port,
+        maxBodyBytes: proxyConfig.maxBodyBytes,
+        poolConfig,
+        signing: {
+            keyId: signingConfig.keyId,
+            secret: signingConfig.secret,
+            require: signingConfig.requireSigning,
+            windowMs: signingConfig.signingWindowMs,
+        },
+    };
+};
+const validateQueryPayload = (payload) => {
+    const base = validateSqlPayload(payload);
+    if (!base.valid) {
+        return { valid: false, error: base.error };
+    }
+    if (base.sql.trim() === '') {
+        return { valid: false, error: { code: 'VALIDATION_ERROR', message: 'sql is required' } };
+    }
+    return { valid: true, sql: base.sql, params: base.params };
+};
+const getSqlModule = async () => {
+    const mod = await import('mssql');
+    return mod;
+};
+const createPool = async (config) => {
+    const mod = await getSqlModule();
+    const connect = mod['connect'];
+    return connect(config);
+};
+const executeQuery = async (pool, sqlQuery, params) => {
+    const requestFunc = pool['request'];
+    const request = requestFunc();
+    params.forEach((param, index) => {
+        const inputFunc = request['input'];
+        inputFunc(`param${index}`, param);
+    });
+    const queryFunc = request['query'];
+    return queryFunc(sqlQuery);
+};
+const handleEndpoint = (path, result) => {
+    const rows = result['recordset'];
+    const rowsAffected = result['rowsAffected'];
+    if (path === '/zin/sqlserver/query') {
+        return { status: 200, body: { rows, rowCount: rowsAffected[0] ?? 0 } };
+    }
+    if (path === '/zin/sqlserver/queryOne') {
+        const firstRow = Array.isArray(rows) ? rows[0] : null;
+        return { status: 200, body: { row: firstRow ?? null } };
+    }
+    if (path === '/zin/sqlserver/exec') {
+        return {
+            status: 200,
+            body: {
+                ok: true,
+                meta: { changes: rowsAffected[0] ?? 0 },
+            },
+        };
+    }
+    return ErrorHandler.toProxyError(404, 'NOT_FOUND', 'Unknown endpoint');
+};
+const createBackend = (pool) => ({
+    name: 'sqlserver',
+    handle: async (request) => {
+        const methodError = RequestValidator.requirePost(request.method);
+        if (methodError) {
+            return ErrorHandler.toProxyError(405, methodError.code, methodError.message);
+        }
+        const parsed = RequestValidator.parseJson(request.body);
+        if (!parsed.ok) {
+            return ErrorHandler.toProxyError(400, parsed.error.code, parsed.error.message);
+        }
+        const sqlValidation = validateQueryPayload(parsed.value);
+        if (!sqlValidation.valid) {
+            const error = sqlValidation.error ?? {
+                code: 'VALIDATION_ERROR',
+                message: 'Invalid SQL payload',
+            };
+            return ErrorHandler.toProxyError(400, error.code, error.message);
+        }
+        try {
+            const result = await executeQuery(pool, sqlValidation.sql ?? '', sqlValidation.params ?? []);
+            return handleEndpoint(request.path, result);
+        }
+        catch (error) {
+            return ErrorHandler.toProxyError(500, 'SQLSERVER_ERROR', String(error));
+        }
+    },
+    health: async () => {
+        try {
+            await executeQuery(pool, 'SELECT 1', []);
+            return { status: 200, body: { status: 'healthy' } };
+        }
+        catch (error) {
+            return ErrorHandler.toProxyError(503, 'UNHEALTHY', String(error));
+        }
+    },
+    shutdown: async () => {
+        const closeFunc = pool['close'];
+        await closeFunc();
+    },
+});
+export const SqlServerProxyServer = Object.freeze({
+    async start(overrides = {}) {
+        const config = resolveConfig(overrides);
+        try {
+            Logger.info(`SQL Server proxy config: proxyHost=${config.host} proxyPort=${config.port} dbHost=${String(config.poolConfig['server'])} dbPort=${String(config.poolConfig['port'])} dbName=${String(config.poolConfig['database'])} dbUser=${String(config.poolConfig['user'])}`);
+        }
+        catch {
+            // noop - logging must not block startup
+        }
+        const pool = await createPool(config.poolConfig);
+        const backend = createBackend(pool);
+        const proxy = createProxyServer({
+            host: config.host,
+            port: config.port,
+            maxBodyBytes: config.maxBodyBytes,
+            backend,
+            verify: async (req, body) => {
+                const verified = await verifyRequestSignature(req, body, config, 'SqlServerProxyServer');
+                if (!verified.ok && verified.error) {
+                    return { ok: false, status: verified.error.status, message: verified.error.message };
+                }
+                return { ok: true };
+            },
+        });
+        await proxy.start();
+        Logger.info(`✓ SQL Server proxy listening on ${config.host}:${config.port}`);
+    },
+});

package/src/proxy/sqlserver/register.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=register.d.ts.map

package/src/proxy/sqlserver/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/proxy/sqlserver/register.ts"],"names":[],"mappings":""}

package/src/proxy/sqlserver/register.js

@@ -0,0 +1,5 @@
+import { ProxyRegistry } from '../ProxyRegistry.js';
+ProxyRegistry.register({
+    name: 'sqlserver',
+    description: 'SQL Server HTTP proxy',
+});

package/src/routes/doc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doc.d.ts","sourceRoot":"","sources":["../../../src/routes/doc.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAInD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAIhD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD;;GAEG;AAEH,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,uBAAuB,EACvB,4BAA4B,EAC5B,aAAa,EACb,kBAAkB,GACnB,MAAM,yBAAyB,CAAC;AAiBjC;;GAEG;AACH,eAAO,MAAM,0BAA0B,GAAI,UAAU,SAAS,KAAG,IAWhE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,2BAA2B,GACtC,SAAS,MAAM,EACf,UAAU,SAAS,KAClB,OAAO,CAAC,OAAO,CAgDjB,CAAC;AASF,eAAO,MAAM,iBAAiB,GAAI,QAAQ,OAAO,KAAG,IAMnD,CAAC;;gCANwC,OAAO,KAAG,IAAI;2CA5EH,SAAS,KAAG,IAAI;2CAiB1D,MAAM,YACL,SAAS,KAClB,OAAO,CAAC,OAAO,CAAC;;AAiEnB,wBAIE"}
+{"version":3,"file":"doc.d.ts","sourceRoot":"","sources":["../../../src/routes/doc.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAInD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAIhD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD;;GAEG;AAEH,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,uBAAuB,EACvB,4BAA4B,EAC5B,aAAa,EACb,kBAAkB,GACnB,MAAM,yBAAyB,CAAC;AAkCjC;;GAEG;AACH,eAAO,MAAM,0BAA0B,GAAI,UAAU,SAAS,KAAG,IAWhE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,2BAA2B,GACtC,SAAS,MAAM,EACf,UAAU,SAAS,KAClB,OAAO,CAAC,OAAO,CAgDjB,CAAC;AASF,eAAO,MAAM,iBAAiB,GAAI,QAAQ,OAAO,KAAG,IAMnD,CAAC;;gCANwC,OAAO,KAAG,IAAI;2CA5EH,SAAS,KAAG,IAAI;2CAiB1D,MAAM,YACL,SAAS,KAClB,OAAO,CAAC,OAAO,CAAC;;AAiEnB,wBAIE"}

package/src/routes/doc.js

@@ -16,8 +16,22 @@ export { MIME_TYPES_MAP } from './common.js';
  */
 // Backward-compatible re-exports
 export { findPackageRoot, findPackageRootAsync, getFrameworkPublicRoots, getFrameworkPublicRootsAsync, getPublicRoot, getPublicRootAsync, } from './publicRoot.js';
+const PUBLIC_ROOT_CACHE_TTL_MS = 3000000000; //50 minutes, effectively caching for the duration of typical dev sessions
+let cachedPublicRoot = null;
+const getCachedPublicRootAsync = async () => {
+    const now = Date.now();
+    if (cachedPublicRoot !== null && cachedPublicRoot.expiresAt > now) {
+        return cachedPublicRoot.value;
+    }
+    const resolved = await getPublicRootAsync();
+    cachedPublicRoot = {
+        value: resolved,
+        expiresAt: now + PUBLIC_ROOT_CACHE_TTL_MS,
+    };
+    return resolved;
+};
 const mapStaticPathAsync = async (urlPath) => {
-    const publicRoot = await getPublicRootAsync();
+    const publicRoot = await getCachedPublicRootAsync();
     const normalize = (p) => (p.startsWith('/') ? p.slice(1) : p);
     if (urlPath === '/doc' || urlPath === '/doc/')
         return publicRoot;
@@ -94,7 +108,7 @@ const handleDocRequest = async (req, res) => {
     const urlPath = req.getPath();
     if (await serveDocumentationFileAsync(urlPath, res))
         return;
-    ErrorRouting.handleNotFound(req, res);
+    await ErrorRouting.handleNotFound(req, res);
 };
 export const registerDocRoutes = (router) => {
     // Root docs entrypoints.

package/src/routes/error.d.ts

@@ -10,12 +10,13 @@ import type * as http from '../node-singletons/http';
  * Debug routes to always render 404/500 responses.
  */
 export declare const registerErrorRoutes: (router: IRouter) => void;
-export declare const ErrorRouting: Readonly<{
+type ErrorRoutingApi = {
     getPublicRoot: () => string;
     registerErrorRoutes: (router: IRouter) => void;
-    handleNotFound: (request: IRequest, response: IResponse, requestId?: string) => void;
-    handleInternalServerErrorWithWrappers: (request: IRequest, response: IResponse, error: unknown, requestId?: string) => void;
+    handleNotFound: (request: IRequest, response: IResponse, requestId?: string) => Promise<void>;
+    handleInternalServerErrorWithWrappers: (request: IRequest, response: IResponse, error: unknown, requestId?: string) => Promise<void>;
     handleInternalServerErrorRaw: (res: http.ServerResponse) => void;
-}>;
+};
+export declare const ErrorRouting: ErrorRoutingApi;
 export default ErrorRouting;
 //# sourceMappingURL=error.d.ts.map

package/src/routes/error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../src/routes/error.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAKnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,KAAK,IAAI,MAAM,uBAAuB,CAAC;AAoKnD;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ,OAAO,KAAG,IAGrD,CAAC;AAEF,eAAO,MAAM,YAAY;;kCALmB,OAAO,KAAG,IAAI;8BA7GzB,QAAQ,YAAY,SAAS,cAAc,MAAM,KAAG,IAAI;qDA4B9E,QAAQ,YACP,SAAS,SACZ,OAAO,cACF,MAAM,KACjB,IAAI;wCA0DoC,IAAI,CAAC,cAAc,KAAG,IAAI;EA8BnE,CAAC;AAEH,eAAe,YAAY,CAAC"}
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../src/routes/error.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAUH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAKnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,KAAK,IAAI,MAAM,uBAAuB,CAAC;AA0KnD;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ,OAAO,KAAG,IAGrD,CAAC;AAEF,KAAK,eAAe,GAAG;IACrB,aAAa,EAAE,MAAM,MAAM,CAAC;IAC5B,mBAAmB,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IAC/C,cAAc,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9F,qCAAqC,EAAE,CACrC,OAAO,EAAE,QAAQ,EACjB,QAAQ,EAAE,SAAS,EACnB,KAAK,EAAE,OAAO,EACd,SAAS,CAAC,EAAE,MAAM,KACf,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,4BAA4B,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,cAAc,KAAK,IAAI,CAAC;CAClE,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,eAMzB,CAAC;AAEH,eAAe,YAAY,CAAC"}

package/src/routes/error.js

@@ -4,7 +4,7 @@
  */
 import { appConfig } from '../config/app.js';
 import { HTTP_HEADERS, MIME_TYPES } from '../config/constants.js';
-import { serveErrorPagesFile, serveZintrustSvgFile } from './errorPages.js';
+import { serveErrorPagesFileAsync, serveZintrustSvgFile, serveZintrustSvgFileAsync, } from './errorPages.js';
 import { getPublicRoot } from './publicRoot.js';
 import { Router } from './Router.js';
 import { ErrorFactory } from '../exceptions/ZintrustError.js';
@@ -31,11 +31,11 @@ const safeJsonStringify = (value) => {
         return '';
     }
 };
-const trySendHtmlErrorPage = (request, response, input) => {
+const trySendHtmlErrorPage = async (request, response, input) => {
     if (!ErrorPageRenderer.shouldSendHtml(request))
         return false;
     const publicRoot = getPublicRoot();
-    const html = ErrorPageRenderer.renderHtml(publicRoot, {
+    const html = await ErrorPageRenderer.renderHtmlAsync(publicRoot, {
         statusCode: input.statusCode,
         errorName: input.errorName,
         errorMessage: input.errorMessage,
@@ -50,18 +50,20 @@ const trySendHtmlErrorPage = (request, response, input) => {
     response.html(html);
     return true;
 };
-const handleNotFound = (request, response, requestId) => {
+const handleNotFound = async (request, response, requestId) => {
     const path = request.getPath();
     if (path.startsWith('/error-pages/')) {
-        serveErrorPagesFile(path, response);
+        await serveErrorPagesFileAsync(path, response);
         return;
     }
     if (path === '/zintrust.svg') {
-        serveZintrustSvgFile(response);
+        if (!(await serveZintrustSvgFileAsync(response))) {
+            serveZintrustSvgFile(response);
+        }
         return;
     }
     response.setStatus(404);
-    if (trySendHtmlErrorPage(request, response, {
+    if (await trySendHtmlErrorPage(request, response, {
         statusCode: 404,
         errorName: 'Not Found',
         errorMessage: 'The page you requested could not be found.',
@@ -70,7 +72,7 @@ const handleNotFound = (request, response, requestId) => {
     }
     response.json(ErrorResponse.notFound('Route', requestId));
 };
-const handleInternalServerErrorWithWrappers = (request, response, error, requestId) => {
+const handleInternalServerErrorWithWrappers = async (request, response, error, requestId) => {
     response.setStatus(500);
     const isDev = appConfig.isDevelopment();
     const err = error instanceof Error ? error : ErrorFactory.createGeneralError('Unknown error', error);
@@ -94,7 +96,7 @@ const handleInternalServerErrorWithWrappers = (request, response, error, request
     const stackRaw = isDev
         ? safeJsonStringify({ name: err.name, message: err.message, stack: err.stack })
         : undefined;
-    if (trySendHtmlErrorPage(request, response, {
+    if (await trySendHtmlErrorPage(request, response, {
         statusCode: 500,
         errorName,
         errorMessage,
@@ -111,14 +113,14 @@ const handleInternalServerErrorRaw = (res) => {
     res.writeHead(500, { [HTTP_HEADERS.CONTENT_TYPE]: MIME_TYPES.JSON });
     res.end(JSON.stringify(ErrorResponse.internalServerError('Internal server error')));
 };
-const handleForced404 = (req, res) => {
-    handleNotFound(req, res);
+const handleForced404 = async (req, res) => {
+    await handleNotFound(req, res);
 };
-const handleForced500 = (req, res) => {
+const handleForced500 = async (req, res) => {
     const forced = ErrorFactory.createGeneralError('Forced 500 route', {
         route: '/500',
     });
-    handleInternalServerErrorWithWrappers(req, res, forced);
+    await handleInternalServerErrorWithWrappers(req, res, forced);
 };
 /**
  * Debug routes to always render 404/500 responses.

package/src/routes/errorPages.d.ts

@@ -5,7 +5,9 @@
 import type { IRouter } from './Router';
 import type { IResponse } from '../http/Response';
 export declare const serveErrorPagesFile: (urlPath: string, response: IResponse) => boolean;
+export declare const serveErrorPagesFileAsync: (urlPath: string, response: IResponse) => Promise<boolean>;
 export declare const serveZintrustSvgFile: (response: IResponse) => boolean;
+export declare const serveZintrustSvgFileAsync: (response: IResponse) => Promise<boolean>;
 export declare const registerErrorPagesRoutes: (router: IRouter) => void;
 declare const _default: {
     registerErrorPagesRoutes: (router: IRouter) => void;

package/src/routes/errorPages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errorPages.d.ts","sourceRoot":"","sources":["../../../src/routes/errorPages.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAInD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAoDhD,eAAO,MAAM,mBAAmB,GAAI,SAAS,MAAM,EAAE,UAAU,SAAS,KAAG,OAkD1E,CAAC;AAeF,eAAO,MAAM,oBAAoB,GAAI,UAAU,SAAS,KAAG,OAE1D,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,QAAQ,OAAO,KAAG,IAO1D,CAAC;;uCAP+C,OAAO,KAAG,IAAI;mCArElB,MAAM,YAAY,SAAS,KAAG,OAAO;;AA8ElF,wBAAiE"}
+{"version":3,"file":"errorPages.d.ts","sourceRoot":"","sources":["../../../src/routes/errorPages.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAInD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AA8JhD,eAAO,MAAM,mBAAmB,GAAI,SAAS,MAAM,EAAE,UAAU,SAAS,KAAG,OAkD1E,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,SAAS,MAAM,EACf,UAAU,SAAS,KAClB,OAAO,CAAC,OAAO,CA4CjB,CAAC;AAmBF,eAAO,MAAM,oBAAoB,GAAI,UAAU,SAAS,KAAG,OAE1D,CAAC;AAEF,eAAO,MAAM,yBAAyB,GAAU,UAAU,SAAS,KAAG,OAAO,CAAC,OAAO,CAKpF,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,QAAQ,OAAO,KAAG,IAO1D,CAAC;;uCAP+C,OAAO,KAAG,IAAI;mCAjIlB,MAAM,YAAY,SAAS,KAAG,OAAO;;AA0IlF,wBAAiE"}

package/src/routes/errorPages.js

@@ -2,6 +2,7 @@
  * Error Pages Static Assets
  * Serves /error-pages/* assets (CSS/JS/SVG/etc) used by HTML error templates.
  */
+import { Cloudflare } from '../config/cloudflare.js';
 import { HTTP_HEADERS, MIME_TYPES } from '../config/constants.js';
 import { MIME_TYPES_MAP, resolveSafePath, tryDecodeURIComponent } from './common.js';
 import { getFrameworkPublicRoots } from './publicRoot.js';
@@ -14,6 +15,74 @@ const getCandidatePublicRoots = () => {
     const unique = new Set(roots.map((root) => root.trim()).filter((root) => root !== ''));
     return [...unique];
 };
+const pathExistsAsync = async (candidate) => {
+    try {
+        await fs.fsPromises.access(candidate);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const isFileAsync = async (candidate) => {
+    try {
+        const stats = await fs.fsPromises.stat(candidate);
+        return stats.isFile();
+    }
+    catch {
+        return false;
+    }
+};
+const findFirstExistingFileAsync = async (candidates) => {
+    const results = await Promise.all(candidates.map(async (candidate) => ({
+        candidate,
+        isFile: await isFileAsync(candidate),
+    })));
+    return results.find((result) => result.isFile)?.candidate;
+};
+const resolveErrorPageFilePathAsync = async (candidateRoots, normalizedRelative) => {
+    const checks = await Promise.all(candidateRoots.map(async (root) => {
+        const baseDir = path.join(root, 'error-pages');
+        const filePath = resolveSafePath(baseDir, normalizedRelative);
+        if (filePath === undefined)
+            return undefined;
+        try {
+            const stats = await fs.fsPromises.stat(filePath);
+            if (stats.isDirectory())
+                return undefined;
+            return filePath;
+        }
+        catch {
+            return undefined;
+        }
+    }));
+    return checks.find((filePath) => typeof filePath === 'string');
+};
+const servePublicRootFileAsync = async (relativePath, response, contentType) => {
+    const candidateRoots = getCandidatePublicRoots();
+    const candidates = candidateRoots.map((root) => path.join(root, relativePath));
+    const filePath = await findFirstExistingFileAsync(candidates);
+    try {
+        if (filePath === undefined || filePath === null) {
+            response.setStatus(404);
+            response.setHeader(HTTP_HEADERS.CONTENT_TYPE, MIME_TYPES.TEXT);
+            response.send('Not Found');
+            return false;
+        }
+        const content = await fs.fsPromises.readFile(filePath);
+        response.setStatus(200);
+        response.setHeader(HTTP_HEADERS.CONTENT_TYPE, contentType);
+        response.send(content);
+        return true;
+    }
+    catch (error) {
+        ErrorFactory.createTryCatchError(`Error serving public file ${filePath}`, error);
+        response.setStatus(500);
+        response.setHeader(HTTP_HEADERS.CONTENT_TYPE, MIME_TYPES.TEXT);
+        response.send('Internal Server Error');
+        return false;
+    }
+};
 const findFirstExistingFile = (candidates) => {
     for (const candidate of candidates) {
         try {
@@ -51,6 +120,28 @@ const servePublicRootFile = (relativePath, response, contentType) => {
         return false;
     }
 };
+const serveAssetsFileAsync = async (urlPath, response) => {
+    const assets = Cloudflare.getAssetsBinding();
+    if (!assets)
+        return false;
+    try {
+        const url = new URL(urlPath, 'https://assets.local');
+        const res = await assets.fetch(url.toString());
+        const contentType = res.headers.get(HTTP_HEADERS.CONTENT_TYPE) ?? MIME_TYPES.TEXT;
+        const body = Buffer.from(await res.arrayBuffer());
+        response.setStatus(res.status);
+        response.setHeader(HTTP_HEADERS.CONTENT_TYPE, contentType);
+        response.send(body);
+        return true;
+    }
+    catch (error) {
+        ErrorFactory.createTryCatchError(`Error serving asset ${urlPath}`, error);
+        response.setStatus(500);
+        response.setHeader(HTTP_HEADERS.CONTENT_TYPE, MIME_TYPES.TEXT);
+        response.send('Internal Server Error');
+        return true;
+    }
+};
 export const serveErrorPagesFile = (urlPath, response) => {
     if (urlPath === '/error-pages' || urlPath === '/error-pages/') {
         response.setStatus(404);
@@ -96,20 +187,69 @@ export const serveErrorPagesFile = (urlPath, response) => {
     response.send('Not Found');
     return true;
 };
-const handleErrorPagesRequest = (req, res) => {
+export const serveErrorPagesFileAsync = async (urlPath, response) => {
+    if (urlPath === '/error-pages' || urlPath === '/error-pages/') {
+        response.setStatus(404);
+        response.setHeader(HTTP_HEADERS.CONTENT_TYPE, MIME_TYPES.TEXT);
+        response.send('Not Found');
+        return true;
+    }
+    if (!urlPath.startsWith('/error-pages/'))
+        return false;
+    if (Cloudflare.getWorkersEnv() !== null) {
+        return serveAssetsFileAsync(urlPath, response);
+    }
+    const candidateRoots = getCandidatePublicRoots();
+    const rawRelative = urlPath.slice('/error-pages/'.length);
+    const normalizedRelative = tryDecodeURIComponent(rawRelative).replaceAll('\\', '/');
+    const filePath = await resolveErrorPageFilePathAsync(candidateRoots, normalizedRelative);
+    try {
+        if (filePath !== undefined && (await pathExistsAsync(filePath))) {
+            const ext = path.extname(filePath).toLowerCase();
+            const contentType = MIME_TYPES_MAP[ext] || 'application/octet-stream';
+            const content = await fs.fsPromises.readFile(filePath);
+            response.setStatus(200);
+            response.setHeader(HTTP_HEADERS.CONTENT_TYPE, contentType);
+            response.send(content);
+            return true;
+        }
+    }
+    catch (error) {
+        ErrorFactory.createTryCatchError(`Error serving error-pages file ${filePath}`, error);
+        response.setStatus(500);
+        response.setHeader(HTTP_HEADERS.CONTENT_TYPE, MIME_TYPES.TEXT);
+        response.send('Internal Server Error');
+        return true;
+    }
+    response.setStatus(404);
+    response.setHeader(HTTP_HEADERS.CONTENT_TYPE, MIME_TYPES.TEXT);
+    response.send('Not Found');
+    return true;
+};
+const handleErrorPagesRequest = async (req, res) => {
     const urlPath = req.getPath();
-    if (serveErrorPagesFile(urlPath, res))
+    if (await serveErrorPagesFileAsync(urlPath, res))
         return;
     res.setStatus(404);
     res.setHeader(HTTP_HEADERS.CONTENT_TYPE, MIME_TYPES.TEXT);
     res.send('Not Found');
 };
-const handleZintrustSvgRequest = (_req, res) => {
-    servePublicRootFile('zintrust.svg', res, MIME_TYPES.SVG);
+const handleZintrustSvgRequest = async (_req, res) => {
+    if (Cloudflare.getWorkersEnv() !== null) {
+        await serveAssetsFileAsync('/zintrust.svg', res);
+        return;
+    }
+    await servePublicRootFileAsync('zintrust.svg', res, MIME_TYPES.SVG);
 };
 export const serveZintrustSvgFile = (response) => {
     return servePublicRootFile('zintrust.svg', response, MIME_TYPES.SVG);
 };
+export const serveZintrustSvgFileAsync = async (response) => {
+    if (Cloudflare.getWorkersEnv() !== null) {
+        return serveAssetsFileAsync('/zintrust.svg', response);
+    }
+    return servePublicRootFileAsync('zintrust.svg', response, MIME_TYPES.SVG);
+};
 export const registerErrorPagesRoutes = (router) => {
     Router.get(router, '/error-pages', handleErrorPagesRequest);
     Router.get(router, '/error-pages/', handleErrorPagesRequest);

package/src/runtime/PluginAutoImports.d.ts

@@ -16,6 +16,7 @@ export declare const PluginAutoImports: Readonly<{
      * adapters/drivers into core registries.
      */
     tryImportProjectAutoImports(): Promise<ImportResult>;
+    tryImportFromFileContents(files: string[]): Promise<ImportResult>;
 }>;
 export {};
 //# sourceMappingURL=PluginAutoImports.d.ts.map

package/src/runtime/PluginAutoImports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PluginAutoImports.d.ts","sourceRoot":"","sources":["../../../src/runtime/PluginAutoImports.ts"],"names":[],"mappings":"AAMA,KAAK,YAAY,GACb;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAChC;IACE,EAAE,EAAE,KAAK,CAAC;IACV,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,WAAW,GAAG,eAAe,CAAC;IACtC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAwBN,eAAO,MAAM,iBAAiB;IAC5B;;;;;;OAMG;mCACkC,OAAO,CAAC,YAAY,CAAC;EA2D1D,CAAC"}
+{"version":3,"file":"PluginAutoImports.d.ts","sourceRoot":"","sources":["../../../src/runtime/PluginAutoImports.ts"],"names":[],"mappings":"AAMA,KAAK,YAAY,GACb;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAChC;IACE,EAAE,EAAE,KAAK,CAAC;IACV,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,WAAW,GAAG,eAAe,CAAC;IACtC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AA0GN,eAAO,MAAM,iBAAiB;IAC5B;;;;;;OAMG;mCACkC,OAAO,CAAC,YAAY,CAAC;qCAmEnB,MAAM,EAAE,GAAG,OAAO,CAAC,YAAY,CAAC;EAavE,CAAC"}