@zintrust/core 0.1.19 → 0.1.21

package/src/routing/doc.js

@@ -0,0 +1,110 @@
+/**
+ * Documentation Routes
+ * Serves static files from /doc/* paths with relaxed CSP headers.
+ */
+import { HTTP_HEADERS } from '../config/constants.js';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import * as fs from '../node-singletons/fs.js';
+import * as path from '../node-singletons/path.js';
+import { MIME_TYPES_MAP, resolveSafePath, tryDecodeURIComponent } from './common.js';
+import { ErrorRouting } from './error.js';
+import { getPublicRootAsync } from './publicRoot.js';
+import { Router } from './Router.js';
+export { MIME_TYPES_MAP } from './common.js';
+/**
+ * Find the package root directory
+ */
+// Backward-compatible re-exports
+export { findPackageRoot, findPackageRootAsync, getFrameworkPublicRoots, getFrameworkPublicRootsAsync, getPublicRoot, getPublicRootAsync, } from './publicRoot.js';
+const mapStaticPathAsync = async (urlPath) => {
+    const publicRoot = await getPublicRootAsync();
+    const normalize = (p) => (p.startsWith('/') ? p.slice(1) : p);
+    if (urlPath === '/doc' || urlPath === '/doc/')
+        return publicRoot;
+    if (urlPath.startsWith('/doc/')) {
+        const rawRelative = urlPath.slice('/doc/'.length);
+        const normalizedRelative = tryDecodeURIComponent(rawRelative).replaceAll('\\', '/');
+        return resolveSafePath(publicRoot, normalize(normalizedRelative));
+    }
+    const normalized = tryDecodeURIComponent(urlPath).replaceAll('\\', '/');
+    return resolveSafePath(publicRoot, normalize(normalized));
+};
+/**
+ * Set relaxed CSP headers for docs (allows external assets like Tailwind CDN, Google Fonts)
+ */
+export const setDocumentationCSPHeaders = (response) => {
+    response.setHeader(HTTP_HEADERS.CONTENT_SECURITY_POLICY, "default-src 'self'; " +
+        "script-src 'self' 'unsafe-inline' 'unsafe-eval' https://cdn.tailwindcss.com; " +
+        "script-src-elem 'self' 'unsafe-inline' https://cdn.tailwindcss.com; " +
+        "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; " +
+        "style-src-elem 'self' 'unsafe-inline' https://fonts.googleapis.com; " +
+        "img-src 'self' data: https:; " +
+        "font-src 'self' data: https://fonts.gstatic.com;");
+};
+/**
+ * Serve a documentation static file (async)
+ */
+export const serveDocumentationFileAsync = async (urlPath, response) => {
+    let filePath = await mapStaticPathAsync(urlPath);
+    if (filePath === undefined) {
+        return false;
+    }
+    try {
+        try {
+            const stats = await fs.fsPromises.stat(filePath);
+            if (stats.isDirectory()) {
+                filePath = path.join(filePath, 'index.html');
+            }
+        }
+        catch {
+            // ignore
+        }
+        const exists = async (p) => {
+            try {
+                await fs.fsPromises.access(p);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        };
+        if (!(await exists(filePath)) && !path.extname(filePath)) {
+            const htmlPath = `${filePath}.html`;
+            if (await exists(htmlPath)) {
+                filePath = htmlPath;
+            }
+        }
+        if (await exists(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('Content-Type', contentType);
+            response.send(content);
+            return true;
+        }
+    }
+    catch (error) {
+        ErrorFactory.createTryCatchError(`Error serving documentation file ${filePath}`, error);
+    }
+    return false;
+};
+const handleDocRequest = async (req, res) => {
+    setDocumentationCSPHeaders(res);
+    const urlPath = req.getPath();
+    if (await serveDocumentationFileAsync(urlPath, res))
+        return;
+    ErrorRouting.handleNotFound(req, res);
+};
+export const registerDocRoutes = (router) => {
+    // Root docs entrypoints.
+    Router.get(router, '/doc', handleDocRequest);
+    Router.get(router, '/doc/', handleDocRequest);
+    // Greedy path match for nested assets like /doc/assets/app.js
+    Router.get(router, '/doc/:path*', handleDocRequest);
+};
+export default {
+    registerDocRoutes,
+    setDocumentationCSPHeaders,
+    serveDocumentationFileAsync,
+};

package/src/routing/error.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Error Routing
+ * Centralizes 404/500 handling and HTML error page rendering.
+ */
+import type { IRequest } from '../http/Request';
+import type { IResponse } from '../http/Response';
+import type * as http from '../node-singletons/http';
+import type { IRouter } from './Router';
+/**
+ * Debug routes to always render 404/500 responses.
+ */
+export declare const registerErrorRoutes: (router: IRouter) => void;
+export declare const ErrorRouting: Readonly<{
+    getPublicRoot: () => string;
+    registerErrorRoutes: (router: IRouter) => void;
+    handleNotFound: (request: IRequest, response: IResponse, requestId?: string) => void;
+    handleInternalServerErrorWithWrappers: (request: IRequest, response: IResponse, error: unknown, requestId?: string) => void;
+    handleInternalServerErrorRaw: (res: http.ServerResponse) => void;
+}>;
+export default ErrorRouting;
+//# sourceMappingURL=error.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../src/routing/error.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,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;AAEnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAwJ/C;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ,OAAO,KAAG,IAGrD,CAAC;AAEF,eAAO,MAAM,YAAY;;kCALmB,OAAO,KAAG,IAAI;8BAlGzB,QAAQ,YAAY,SAAS,cAAc,MAAM,KAAG,IAAI;qDAiB9E,QAAQ,YACP,SAAS,SACZ,OAAO,cACF,MAAM,KACjB,IAAI;wCA0DoC,IAAI,CAAC,cAAc,KAAG,IAAI;EA8BnE,CAAC;AAEH,eAAe,YAAY,CAAC"}

package/src/routing/error.js

@@ -0,0 +1,126 @@
+/**
+ * Error Routing
+ * Centralizes 404/500 handling and HTML error page rendering.
+ */
+import { appConfig } from '../config/app.js';
+import { HTTP_HEADERS, MIME_TYPES } from '../config/constants.js';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import { ErrorPageRenderer } from '../http/error-pages/ErrorPageRenderer.js';
+import { ErrorResponse } from '../http/ErrorResponse.js';
+import { getPublicRoot } from './publicRoot.js';
+import { Router } from './Router.js';
+const redactHeaders = (headers) => {
+    const redacted = new Set(['authorization', 'cookie', 'set-cookie', 'x-api-key']);
+    const out = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (redacted.has(key.toLowerCase())) {
+            out[key] = '[redacted]';
+            continue;
+        }
+        out[key] = value;
+    }
+    return out;
+};
+const safeJsonStringify = (value) => {
+    try {
+        return JSON.stringify(value, null, 2) ?? '';
+    }
+    catch {
+        return '';
+    }
+};
+const trySendHtmlErrorPage = (request, response, input) => {
+    if (!ErrorPageRenderer.shouldSendHtml(request))
+        return false;
+    const publicRoot = getPublicRoot();
+    const html = ErrorPageRenderer.renderHtml(publicRoot, {
+        statusCode: input.statusCode,
+        errorName: input.errorName,
+        errorMessage: input.errorMessage,
+        requestPath: request.getPath(),
+        stackPretty: input.stackPretty,
+        stackRaw: input.stackRaw,
+        requestPretty: input.requestPretty,
+        requestRaw: input.requestRaw,
+    });
+    if (html === undefined)
+        return false;
+    response.html(html);
+    return true;
+};
+const handleNotFound = (request, response, requestId) => {
+    response.setStatus(404);
+    if (trySendHtmlErrorPage(request, response, {
+        statusCode: 404,
+        errorName: 'Not Found',
+        errorMessage: 'The page you requested could not be found.',
+    })) {
+        return;
+    }
+    response.json(ErrorResponse.notFound('Route', requestId));
+};
+const handleInternalServerErrorWithWrappers = (request, response, error, requestId) => {
+    response.setStatus(500);
+    const isDev = appConfig.isDevelopment();
+    const err = error instanceof Error ? error : ErrorFactory.createGeneralError('Unknown error', error);
+    const errorName = isDev ? err.name || 'Error' : 'Internal Server Error';
+    const errorMessage = isDev
+        ? err.message || 'An error has occurred'
+        : 'Something went wrong while handling your request.';
+    const requestObj = isDev
+        ? {
+            method: request.getMethod(),
+            path: request.getPath(),
+            query: request.getQuery(),
+            headers: redactHeaders(request.getHeaders()),
+        }
+        : undefined;
+    const requestPretty = requestObj === undefined
+        ? undefined
+        : `Request\n\nMethod: ${requestObj.method}\nPath: ${requestObj.path}\n\nHeaders:\n${safeJsonStringify(requestObj.headers)}\n\nQuery:\n${safeJsonStringify(requestObj.query)}`;
+    const requestRaw = requestObj === undefined ? undefined : safeJsonStringify(requestObj);
+    const stackPretty = isDev ? (err.stack ?? '') : undefined;
+    const stackRaw = isDev
+        ? safeJsonStringify({ name: err.name, message: err.message, stack: err.stack })
+        : undefined;
+    if (trySendHtmlErrorPage(request, response, {
+        statusCode: 500,
+        errorName,
+        errorMessage,
+        stackPretty,
+        stackRaw,
+        requestPretty,
+        requestRaw,
+    })) {
+        return;
+    }
+    response.json(ErrorResponse.internalServerError('Internal server error', requestId, isDev ? err.stack : undefined));
+};
+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 handleForced500 = (req, res) => {
+    const forced = ErrorFactory.createGeneralError('Forced 500 route', {
+        route: '/500',
+    });
+    handleInternalServerErrorWithWrappers(req, res, forced);
+};
+/**
+ * Debug routes to always render 404/500 responses.
+ */
+export const registerErrorRoutes = (router) => {
+    Router.get(router, '/404', handleForced404);
+    Router.get(router, '/500', handleForced500);
+};
+export const ErrorRouting = Object.freeze({
+    getPublicRoot,
+    registerErrorRoutes,
+    handleNotFound,
+    handleInternalServerErrorWithWrappers,
+    handleInternalServerErrorRaw,
+});
+export default ErrorRouting;

package/src/routing/errorPages.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Error Pages Static Assets
+ * Serves /error-pages/* assets (CSS/JS/SVG/etc) used by HTML error templates.
+ */
+import type { IResponse } from '../http/Response';
+import type { IRouter } from './Router';
+export declare const serveErrorPagesFile: (urlPath: string, response: IResponse) => boolean;
+export declare const registerErrorPagesRoutes: (router: IRouter) => void;
+declare const _default: {
+    registerErrorPagesRoutes: (router: IRouter) => void;
+    serveErrorPagesFile: (urlPath: string, response: IResponse) => boolean;
+};
+export default _default;
+//# sourceMappingURL=errorPages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errorPages.d.ts","sourceRoot":"","sources":["../../../src/routing/errorPages.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAKhD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAiC/C,eAAO,MAAM,mBAAmB,GAAI,SAAS,MAAM,EAAE,UAAU,SAAS,KAAG,OAsD1E,CAAC;AAeF,eAAO,MAAM,wBAAwB,GAAI,QAAQ,OAAO,KAAG,IAO1D,CAAC;;uCAP+C,OAAO,KAAG,IAAI;mCArElB,MAAM,YAAY,SAAS,KAAG,OAAO;;AA8ElF,wBAAiE"}

package/src/routing/errorPages.js

@@ -0,0 +1,103 @@
+/**
+ * Error Pages Static Assets
+ * Serves /error-pages/* assets (CSS/JS/SVG/etc) used by HTML error templates.
+ */
+import { HTTP_HEADERS, MIME_TYPES } from '../config/constants.js';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import * as fs from '../node-singletons/fs.js';
+import * as path from '../node-singletons/path.js';
+import { MIME_TYPES_MAP, resolveSafePath, tryDecodeURIComponent } from './common.js';
+import { getPublicRoot } from './publicRoot.js';
+import { Router } from './Router.js';
+const servePublicRootFile = (relativePath, response, contentType) => {
+    const publicRoot = getPublicRoot();
+    const filePath = path.join(publicRoot, relativePath);
+    try {
+        if (!fs.existsSync(filePath) || fs.statSync(filePath).isDirectory()) {
+            response.setStatus(404);
+            response.setHeader(HTTP_HEADERS.CONTENT_TYPE, MIME_TYPES.TEXT);
+            response.send('Not Found');
+            return;
+        }
+        const content = fs.readFileSync(filePath);
+        response.setStatus(200);
+        response.setHeader(HTTP_HEADERS.CONTENT_TYPE, contentType);
+        response.send(content);
+        return;
+    }
+    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;
+    }
+};
+export const serveErrorPagesFile = (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;
+    const publicRoot = getPublicRoot();
+    const baseDir = path.join(publicRoot, 'error-pages');
+    const rawRelative = urlPath.slice('/error-pages/'.length);
+    const normalizedRelative = tryDecodeURIComponent(rawRelative).replaceAll('\\', '/');
+    const filePath = resolveSafePath(baseDir, normalizedRelative);
+    if (filePath === undefined) {
+        response.setStatus(404);
+        response.setHeader(HTTP_HEADERS.CONTENT_TYPE, MIME_TYPES.TEXT);
+        response.send('Not Found');
+        return true;
+    }
+    try {
+        if (fs.existsSync(filePath) && fs.statSync(filePath).isDirectory()) {
+            response.setStatus(404);
+            response.setHeader(HTTP_HEADERS.CONTENT_TYPE, MIME_TYPES.TEXT);
+            response.send('Not Found');
+            return true;
+        }
+        if (!fs.existsSync(filePath)) {
+            response.setStatus(404);
+            response.setHeader(HTTP_HEADERS.CONTENT_TYPE, MIME_TYPES.TEXT);
+            response.send('Not Found');
+            return true;
+        }
+        const ext = path.extname(filePath).toLowerCase();
+        const contentType = MIME_TYPES_MAP[ext] || 'application/octet-stream';
+        const content = fs.readFileSync(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;
+    }
+};
+const handleErrorPagesRequest = (req, res) => {
+    const urlPath = req.getPath();
+    if (serveErrorPagesFile(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);
+};
+export const registerErrorPagesRoutes = (router) => {
+    Router.get(router, '/error-pages', handleErrorPagesRequest);
+    Router.get(router, '/error-pages/', handleErrorPagesRequest);
+    Router.get(router, '/error-pages/:path*', handleErrorPagesRequest);
+    // Used by the HTML error templates (logo in footer).
+    Router.get(router, '/zintrust.svg', handleZintrustSvgRequest);
+};
+export default { registerErrorPagesRoutes, serveErrorPagesFile };

package/src/routing/publicRoot.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Public Root Resolution
+ * Determines where framework/app static assets live (public/ or dist/public).
+ */
+/**
+ * Find the package root directory.
+ */
+export declare const findPackageRoot: (startDir: string) => string;
+/**
+ * Find the package root directory (async).
+ */
+export declare const findPackageRootAsync: (startDir: string) => Promise<string>;
+/**
+ * Framework public roots (dist/public preferred).
+ */
+export declare const getFrameworkPublicRoots: () => string[];
+export declare const getFrameworkPublicRootsAsync: () => Promise<string[]>;
+/**
+ * Resolve the effective public root.
+ * Prefers app-local `public/` when present; otherwise falls back to framework public roots.
+ */
+export declare const getPublicRoot: () => string;
+/**
+ * Resolve the effective public root (async).
+ */
+export declare const getPublicRootAsync: () => Promise<string>;
+//# sourceMappingURL=publicRoot.d.ts.map

package/src/routing/publicRoot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publicRoot.d.ts","sourceRoot":"","sources":["../../../src/routing/publicRoot.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,UAAU,MAAM,KAAG,MAalD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAAU,UAAU,MAAM,KAAG,OAAO,CAAC,MAAM,CAkB3E,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,QAAO,MAAM,EAIhD,CAAC;AAEF,eAAO,MAAM,4BAA4B,QAAa,OAAO,CAAC,MAAM,EAAE,CAIrE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,QAAO,MAgBhC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,QAAa,OAAO,CAAC,MAAM,CA+BzD,CAAC"}

package/src/routing/publicRoot.js

@@ -0,0 +1,110 @@
+/**
+ * Public Root Resolution
+ * Determines where framework/app static assets live (public/ or dist/public).
+ */
+import { esmDirname } from '../common/index.js';
+import * as fs from '../node-singletons/fs.js';
+import * as path from '../node-singletons/path.js';
+/**
+ * Find the package root directory.
+ */
+export const findPackageRoot = (startDir) => {
+    let current = startDir;
+    for (let i = 0; i < 10; i++) {
+        try {
+            if (fs.existsSync(path.join(current, 'package.json')))
+                return current;
+        }
+        catch {
+            // ignore access errors
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return startDir;
+};
+/**
+ * Find the package root directory (async).
+ */
+export const findPackageRootAsync = async (startDir) => {
+    const findUp = async (current, depth) => {
+        if (depth >= 10)
+            return startDir;
+        try {
+            await fs.fsPromises.access(path.join(current, 'package.json'));
+            return current;
+        }
+        catch {
+            // ignore
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            return startDir;
+        return findUp(parent, depth + 1);
+    };
+    return findUp(startDir, 0);
+};
+/**
+ * Framework public roots (dist/public preferred).
+ */
+export const getFrameworkPublicRoots = () => {
+    const thisDir = esmDirname(import.meta.url);
+    const packageRoot = findPackageRoot(thisDir);
+    return [path.join(packageRoot, 'dist/public'), path.join(packageRoot, 'public')];
+};
+export const getFrameworkPublicRootsAsync = async () => {
+    const thisDir = esmDirname(import.meta.url);
+    const packageRoot = await findPackageRootAsync(thisDir);
+    return [path.join(packageRoot, 'dist/public'), path.join(packageRoot, 'public')];
+};
+/**
+ * Resolve the effective public root.
+ * Prefers app-local `public/` when present; otherwise falls back to framework public roots.
+ */
+export const getPublicRoot = () => {
+    const appRoots = [path.join(process.cwd(), 'public')];
+    const candidates = [...appRoots, ...getFrameworkPublicRoots()];
+    // Prefer a root that contains an index.html (common for docs + dev portal).
+    const hasIndex = (root) => fs.existsSync(path.join(root, 'index.html'));
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate) && hasIndex(candidate))
+            return candidate;
+    }
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return candidates[0];
+};
+/**
+ * Resolve the effective public root (async).
+ */
+export const getPublicRootAsync = async () => {
+    const appRoots = [path.join(process.cwd(), 'public')];
+    const fwRoots = await getFrameworkPublicRootsAsync();
+    const candidates = [...appRoots, ...fwRoots];
+    const exists = async (p) => {
+        try {
+            await fs.fsPromises.access(p);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const hasIndex = async (root) => exists(path.join(root, 'index.html'));
+    const checks = await Promise.all(candidates.map(async (candidate) => {
+        const rootExists = await exists(candidate);
+        const indexExists = rootExists ? await hasIndex(candidate) : false;
+        return { candidate, rootExists, indexExists };
+    }));
+    const withIndex = checks.find((c) => c.indexExists);
+    if (withIndex)
+        return withIndex.candidate;
+    const firstExisting = checks.find((c) => c.rootExists);
+    if (firstExisting)
+        return firstExisting.candidate;
+    return candidates[0];
+};

package/src/runtime/PluginAutoImports.d.ts

@@ -0,0 +1,21 @@
+type ImportResult = {
+    ok: true;
+    loadedPath: string;
+} | {
+    ok: false;
+    loadedPath?: string;
+    reason: 'not-found' | 'import-failed';
+    errorMessage?: string;
+};
+export declare const PluginAutoImports: Readonly<{
+    /**
+     * Best-effort import of a project's `src/zintrust.plugins.ts` file.
+     *
+     * This file is generated/maintained by `zin plugin install` and contains
+     * side-effect imports (e.g. `@zintrust/db-mysql/register`) which register
+     * adapters/drivers into core registries.
+     */
+    tryImportProjectAutoImports(): Promise<ImportResult>;
+}>;
+export {};
+//# sourceMappingURL=PluginAutoImports.d.ts.map

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

@@ -0,0 +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;AAmBN,eAAO,MAAM,iBAAiB;IAC5B;;;;;;OAMG;mCACkC,OAAO,CAAC,YAAY,CAAC;EAgC1D,CAAC"}

package/src/runtime/PluginAutoImports.js

@@ -0,0 +1,59 @@
+import { pathToFileURL } from '../node-singletons/url.js';
+import { Logger } from '../config/logger.js';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import { existsSync } from '../node-singletons/fs.js';
+import * as path from '../node-singletons/path.js';
+const resolveProjectRoot = () => {
+    const fromEnv = process.env['ZINTRUST_PROJECT_ROOT'];
+    if (typeof fromEnv === 'string' && fromEnv.trim().length > 0)
+        return fromEnv.trim();
+    return process.cwd();
+};
+const getCandidates = (projectRoot) => {
+    return [
+        // Dev (tsx)
+        path.join(projectRoot, 'src', 'zintrust.plugins.ts'),
+        // Production build output (most common)
+        path.join(projectRoot, 'dist', 'src', 'zintrust.plugins.js'),
+        // Fallback (in case someone transpiles without /dist)
+        path.join(projectRoot, 'src', 'zintrust.plugins.js'),
+    ];
+};
+export const PluginAutoImports = Object.freeze({
+    /**
+     * Best-effort import of a project's `src/zintrust.plugins.ts` file.
+     *
+     * This file is generated/maintained by `zin plugin install` and contains
+     * side-effect imports (e.g. `@zintrust/db-mysql/register`) which register
+     * adapters/drivers into core registries.
+     */
+    async tryImportProjectAutoImports() {
+        const projectRoot = resolveProjectRoot();
+        const candidates = getCandidates(projectRoot);
+        for (const candidate of candidates) {
+            if (!existsSync(candidate))
+                continue;
+            try {
+                const url = pathToFileURL(candidate).href;
+                // eslint-disable-next-line no-await-in-loop
+                await import(url);
+                return { ok: true, loadedPath: candidate };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                Logger.warn('[plugins] Failed to import plugin auto-imports', {
+                    candidate,
+                    errorMessage,
+                });
+                // Keep error creation for consistent structure (but do not throw).
+                ErrorFactory.createTryCatchError('Failed to import project plugin auto-imports', {
+                    candidate,
+                    error,
+                });
+                return { ok: false, loadedPath: candidate, reason: 'import-failed', errorMessage };
+            }
+        }
+        Logger.debug('[plugins] No plugin auto-imports file found', { projectRoot, candidates });
+        return { ok: false, reason: 'not-found' };
+    },
+});

package/src/runtime/PluginManager.d.ts

@@ -1,8 +1,4 @@
-/**
- * Plugin Manager
- * Handles installation and removal of framework plugins.
- */
-import { PluginDefinition } from './PluginRegistry';
+import type { PluginDefinition } from './PluginRegistry';
 export declare const PluginManager: Readonly<{
     /**
      * List all available plugins

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

@@ -1 +1 @@
-{"version":3,"file":"PluginManager.d.ts","sourceRoot":"","sources":["../../../src/runtime/PluginManager.ts"],"names":[],"mappings":"AAEA;;;GAGG;AASH,OAAO,EAAE,gBAAgB,EAAkB,MAAM,yBAAyB,CAAC;AA6Q3E,eAAO,MAAM,aAAa;IACxB;;OAEG;YACK,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAIxC;;OAEG;yBACkB,MAAM,GAAG,MAAM,GAAG,IAAI;IAW3C;;OAEG;0BACyB,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA0DrD;;OAEG;sBACqB,MAAM,YAAY;QAAE,cAAc,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA8BrF;;;;OAIG;wBACuB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;EA2ChD,CAAC"}
+{"version":3,"file":"PluginManager.d.ts","sourceRoot":"","sources":["../../../src/runtime/PluginManager.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,gBAAgB,EAAC,MAAM,yBAAyB,CAAC;AA0R/D,eAAO,MAAM,aAAa;IACxB;;OAEG;YACK,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAIxC;;OAEG;yBACkB,MAAM,GAAG,MAAM,GAAG,IAAI;IAW3C;;OAEG;0BACyB,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA0DrD;;OAEG;sBACqB,MAAM,YAAY;QAAE,cAAc,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA8BrF;;;;OAIG;wBACuB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;EA2ChD,CAAC"}