@zintrust/core 0.4.26 → 0.4.28

package/routes/DirectTestRoutes.js

@@ -0,0 +1,480 @@
+/**
+ * Redis Test Routes
+ * Tests Redis connectivity via proxy from Cloudflare Workers
+ */
+import { Cache } from '../src/cache/Cache.js';
+import { Cloudflare } from '../src/config/cloudflare.js';
+import { ErrorFactory } from '../src/exceptions/ZintrustError.js';
+import { isInt, isNonEmptyString } from '../src/helper/index.js';
+import { Mail } from '../src/tools/mail/index.js';
+import { WorkerFactory } from '../packages/workers/src/index.js';
+import { RedisProxyAdapter } from '../packages/cache-redis/src/index.js';
+const ADVANCED_WORKER_SPEC = 'https://wk.zintrust.com/AdvancEmailWorker.js';
+const runRedisTest = async (driver, label) => {
+    const key = `zt:redis-test:${label}:${Date.now()}`;
+    const value = { ok: true, ts: new Date().toISOString() };
+    await driver.set(key, value, 30);
+    const read = await driver.get(key);
+    const exists = await driver.has(key);
+    await driver.delete(key);
+    const existsAfterDelete = await driver.has(key);
+    return {
+        key,
+        wrote: value,
+        read,
+        exists,
+        existsAfterDelete,
+    };
+};
+const getCacheRouteContext = (req) => {
+    const isFlare = Cloudflare?.getWorkersEnv() !== null;
+    const storeNameRaw = req.getQueryParam?.('store');
+    const storeName = isNonEmptyString(storeNameRaw) ? storeNameRaw.trim() : undefined;
+    return {
+        storeName,
+        runtime: isFlare ? 'Cloudflare Workers' : 'Node',
+    };
+};
+const getCacheStore = (storeName) => storeName === undefined ? Cache : Cache.store(storeName);
+const getCacheKeyOrDefault = (req, fallbackPrefix) => {
+    const raw = req.getQueryParam?.('key');
+    const key = Array.isArray(raw) ? raw[0] : raw;
+    if (isNonEmptyString(key))
+        return key.trim();
+    return `${fallbackPrefix}:${Date.now()}`;
+};
+const getTtlSeconds = (req) => {
+    const raw = req.getQueryParam?.('ttl');
+    const value = Array.isArray(raw) ? raw[0] : raw;
+    if (!isInt(value, true, { min: 1, max: 60 * 60 }))
+        return undefined;
+    return Number(value);
+};
+const getValueForSet = (req) => {
+    const raw = req.getQueryParam?.('value');
+    const value = Array.isArray(raw) ? raw[0] : raw;
+    if (!isNonEmptyString(value)) {
+        return { ok: true, ts: new Date().toISOString() };
+    }
+    const v = value.trim();
+    if (v.startsWith('{') || v.startsWith('[')) {
+        try {
+            return JSON.parse(v);
+        }
+        catch {
+            return v;
+        }
+    }
+    return v;
+};
+export const testCacheSmoke = async (req, res) => {
+    const ctx = getCacheRouteContext(req);
+    const key = getCacheKeyOrDefault(req, 'cache-smoke');
+    const ttlSeconds = getTtlSeconds(req) ?? 30;
+    const value = { ok: true, ts: new Date().toISOString(), key };
+    try {
+        const store = getCacheStore(ctx.storeName);
+        await store.set(key, value, ttlSeconds);
+        const read = await store.get(key);
+        const exists = await store.has(key);
+        await store.delete(key);
+        const existsAfterDelete = await store.has(key);
+        res.json({
+            success: true,
+            message: 'Cache smoke test successful',
+            runtime: ctx.runtime,
+            store: ctx.storeName ?? 'default',
+            key,
+            ttlSeconds,
+            wrote: value,
+            read,
+            exists,
+            existsAfterDelete,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: 'Cache smoke test failed',
+            runtime: ctx.runtime,
+            store: ctx.storeName ?? 'default',
+            key,
+            details: String(error),
+            timestamp: new Date().toISOString(),
+        });
+    }
+};
+export const testCacheSet = async (req, res) => {
+    const ctx = getCacheRouteContext(req);
+    const key = getCacheKeyOrDefault(req, 'cache-set');
+    const ttlSeconds = getTtlSeconds(req);
+    const value = getValueForSet(req);
+    try {
+        const store = getCacheStore(ctx.storeName);
+        await store.set(key, value, ttlSeconds);
+        res.json({
+            success: true,
+            message: 'Cache set successful',
+            runtime: ctx.runtime,
+            store: ctx.storeName ?? 'default',
+            key,
+            ttlSeconds: ttlSeconds ?? null,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: 'Cache set failed',
+            runtime: ctx.runtime,
+            store: ctx.storeName ?? 'default',
+            key,
+            details: String(error),
+            timestamp: new Date().toISOString(),
+        });
+    }
+};
+export const testCacheGet = async (req, res) => {
+    const ctx = getCacheRouteContext(req);
+    const rawKey = req.getQueryParam?.('key');
+    const key = Array.isArray(rawKey) ? rawKey[0] : rawKey;
+    if (!isNonEmptyString(key)) {
+        res.status(400).json({
+            success: false,
+            error: 'Missing key',
+            message: 'Provide ?key=...',
+            runtime: ctx.runtime,
+            store: ctx.storeName ?? 'default',
+            timestamp: new Date().toISOString(),
+        });
+        return;
+    }
+    const trimmedKey = key.trim();
+    try {
+        const store = getCacheStore(ctx.storeName);
+        const value = await store.get(trimmedKey);
+        res.json({
+            success: true,
+            message: 'Cache get successful',
+            runtime: ctx.runtime,
+            store: ctx.storeName ?? 'default',
+            key: trimmedKey,
+            value,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: 'Cache get failed',
+            runtime: ctx.runtime,
+            store: ctx.storeName ?? 'default',
+            key: trimmedKey,
+            details: String(error),
+            timestamp: new Date().toISOString(),
+        });
+    }
+};
+export const testCacheHas = async (req, res) => {
+    const ctx = getCacheRouteContext(req);
+    const rawKey = req.getQueryParam?.('key');
+    const key = Array.isArray(rawKey) ? rawKey[0] : rawKey;
+    if (!isNonEmptyString(key)) {
+        res.status(400).json({
+            success: false,
+            error: 'Missing key',
+            message: 'Provide ?key=...',
+            runtime: ctx.runtime,
+            store: ctx.storeName ?? 'default',
+            timestamp: new Date().toISOString(),
+        });
+        return;
+    }
+    const trimmedKey = key.trim();
+    try {
+        const store = getCacheStore(ctx.storeName);
+        const exists = await store.has(trimmedKey);
+        res.json({
+            success: true,
+            message: 'Cache has successful',
+            runtime: ctx.runtime,
+            store: ctx.storeName ?? 'default',
+            key: trimmedKey,
+            exists,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: 'Cache has failed',
+            runtime: ctx.runtime,
+            store: ctx.storeName ?? 'default',
+            key: trimmedKey,
+            details: String(error),
+            timestamp: new Date().toISOString(),
+        });
+    }
+};
+export const testCacheDelete = async (req, res) => {
+    const ctx = getCacheRouteContext(req);
+    const rawKey = req.getQueryParam?.('key');
+    const key = Array.isArray(rawKey) ? rawKey[0] : rawKey;
+    if (!isNonEmptyString(key)) {
+        res.status(400).json({
+            success: false,
+            error: 'Missing key',
+            message: 'Provide ?key=...',
+            runtime: ctx.runtime,
+            store: ctx.storeName ?? 'default',
+            timestamp: new Date().toISOString(),
+        });
+        return;
+    }
+    const trimmedKey = key.trim();
+    try {
+        const store = getCacheStore(ctx.storeName);
+        await store.delete(trimmedKey);
+        const existsAfterDelete = await store.has(trimmedKey);
+        res.json({
+            success: true,
+            message: 'Cache delete successful',
+            runtime: ctx.runtime,
+            store: ctx.storeName ?? 'default',
+            key: trimmedKey,
+            existsAfterDelete,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: 'Cache delete failed',
+            runtime: ctx.runtime,
+            store: ctx.storeName ?? 'default',
+            key: trimmedKey,
+            details: String(error),
+            timestamp: new Date().toISOString(),
+        });
+    }
+};
+export const testCacheClear = async (req, res) => {
+    const ctx = getCacheRouteContext(req);
+    try {
+        const store = getCacheStore(ctx.storeName);
+        await store.clear();
+        res.json({
+            success: true,
+            message: 'Cache clear executed',
+            note: 'Some drivers (e.g., kv-remote) may not implement clear() and will no-op.',
+            runtime: ctx.runtime,
+            store: ctx.storeName ?? 'default',
+            timestamp: new Date().toISOString(),
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: 'Cache clear failed',
+            runtime: ctx.runtime,
+            store: ctx.storeName ?? 'default',
+            details: String(error),
+            timestamp: new Date().toISOString(),
+        });
+    }
+};
+/**
+ * Test Redis via HTTP proxy
+ */
+export const testRedisProxy = async (_req, res) => {
+    const isFlare = Cloudflare?.getWorkersEnv() !== null;
+    try {
+        const driver = RedisProxyAdapter.create();
+        const result = await runRedisTest(driver, 'proxy');
+        res.json({
+            success: true,
+            message: 'Redis proxy test successful',
+            adapter: 'packages/cache-redis (proxy)',
+            runtime: isFlare ? 'Cloudflare Workers' : 'Node',
+            data: result,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: 'Redis proxy test failed',
+            details: String(error),
+            adapter: 'packages/cache-redis (proxy)',
+            runtime: isFlare ? 'Cloudflare Workers' : 'Node',
+            timestamp: new Date().toISOString(),
+        });
+    }
+};
+/**
+ * Test URL-based worker processor resolution (Cloudflare Workers)
+ */
+export const testWorkerProcessorUrl = async (_req, res) => {
+    const isFlare = Cloudflare?.getWorkersEnv() !== null;
+    try {
+        let resolveProcessorSpec = null;
+        try {
+            const candidate = WorkerFactory['resolveProcessorSpec'];
+            if (typeof candidate === 'function') {
+                resolveProcessorSpec = candidate;
+            }
+        }
+        catch {
+            resolveProcessorSpec = null;
+        }
+        if (resolveProcessorSpec === null) {
+            throw ErrorFactory.createConfigError('PROCESSOR_SPEC_RESOLVER_UNAVAILABLE');
+        }
+        const resolved = await resolveProcessorSpec(ADVANCED_WORKER_SPEC);
+        if (resolved === undefined || resolved === null) {
+            throw ErrorFactory.createConfigError('PROCESSOR_SPEC_NOT_RESOLVED');
+        }
+        res.json({
+            success: true,
+            message: 'Processor spec resolved successfully',
+            spec: ADVANCED_WORKER_SPEC,
+            runtime: isFlare ? 'Cloudflare Workers' : 'Node',
+            timestamp: new Date().toISOString(),
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: 'Processor spec resolution failed',
+            spec: ADVANCED_WORKER_SPEC,
+            details: String(error),
+            runtime: isFlare ? 'Cloudflare Workers' : 'Node',
+            timestamp: new Date().toISOString(),
+        });
+    }
+};
+const getMailConfig = () => {
+    const mailHost = process.env['MAIL_HOST'] ?? '';
+    const mailUsername = process.env['MAIL_USERNAME'] ?? '';
+    const mailPassword = process.env['MAIL_PASSWORD'] ?? '';
+    const mailDriver = process.env['MAIL_DRIVER'] ?? process.env['MAIL_CONNECTION'] ?? 'smtp';
+    return {
+        mailHost,
+        mailUsername,
+        mailPassword,
+        mailDriver,
+        isConfigured: Boolean(mailHost) && Boolean(mailUsername) && Boolean(mailPassword),
+        configStatus: {
+            driver: mailDriver,
+            host: mailHost ? 'configured' : 'missing',
+            username: mailUsername ? 'configured' : 'missing',
+            password: mailPassword ? 'configured' : 'missing',
+        },
+    };
+};
+const getMailErrorDetails = (errorMessage) => {
+    const isProxyAuthError = errorMessage.includes('SMTP proxy forbidden') ||
+        errorMessage.includes('SMTP proxy unauthorized') ||
+        errorMessage.includes('ForbiddenError');
+    const isConnectionError = errorMessage.includes('ConnectionError') ||
+        errorMessage.includes('ECONNREFUSED') ||
+        errorMessage.includes('ETIMEDOUT');
+    const isAuthError = errorMessage.includes('auth') || errorMessage.includes('535') || errorMessage.includes('530');
+    const isConfigError = errorMessage.includes('Configuration') || errorMessage.includes('config');
+    if (isProxyAuthError) {
+        return {
+            errorType: 'proxy-auth',
+            suggestion: 'Ensure SMTP proxy signing credentials match between worker and proxy (SMTP_PROXY_KEY_ID/SMTP_PROXY_SECRET or APP_KEY).',
+        };
+    }
+    if (isConnectionError) {
+        return {
+            errorType: 'connection',
+            suggestion: 'Check MAIL_HOST, MAIL_PORT, and network connectivity',
+        };
+    }
+    if (isAuthError) {
+        return {
+            errorType: 'authentication',
+            suggestion: 'Verify MAIL_USERNAME and MAIL_PASSWORD are correct',
+        };
+    }
+    if (isConfigError) {
+        return {
+            errorType: 'configuration',
+            suggestion: 'Check mail driver configuration',
+        };
+    }
+    return {
+        errorType: 'unknown',
+        suggestion: 'Check mail service logs for more details',
+    };
+};
+const handleMailConfiguration = (mailConfig, isFlare, res) => {
+    if (mailConfig.mailDriver === 'smtp' && !mailConfig.isConfigured) {
+        res.status(400).json({
+            success: false,
+            error: 'Mail configuration incomplete',
+            message: 'SMTP mail driver requires MAIL_HOST, MAIL_USERNAME, and MAIL_PASSWORD environment variables',
+            config: mailConfig.configStatus,
+            runtime: isFlare ? 'Cloudflare Workers' : 'Node',
+            timestamp: new Date().toISOString(),
+        });
+        return false;
+    }
+    return true;
+};
+/**
+ * Test sending email using configured mail driver
+ */
+export const testMailSend = async (req, res) => {
+    const isFlare = Cloudflare?.getWorkersEnv() !== null;
+    const mailConfig = getMailConfig();
+    if (!handleMailConfiguration(mailConfig, isFlare, res))
+        return;
+    try {
+        const to = req.getQueryParam?.('to') ?? 'test@zintrust.com';
+        const subject = 'SMTP test from ZinTrust';
+        const htmlContent = await Mail.render({
+            template: 'welcome',
+            variables: { alertType: 'critical' },
+        });
+        const result = await Mail.send({
+            to: to ?? 'test@zintrust.com',
+            subject: subject ?? 'Worker Notification from ZinTrust',
+            text: `Worker job completed successfully.`,
+            html: htmlContent,
+            from: {
+                address: 'no-reply@engage.vizo.app',
+                name: 'ZinTrust Advanced Worker',
+            },
+        });
+        res.json({
+            success: true,
+            message: 'Mail send test completed successfully',
+            to,
+            result,
+            config: mailConfig.configStatus,
+            runtime: isFlare ? 'Cloudflare Workers' : 'Node',
+            timestamp: new Date().toISOString(),
+        });
+    }
+    catch (error) {
+        const errorMessage = String(error);
+        const errorDetails = typeof error === 'object' && error !== null && 'details' in error
+            ? error.details
+            : undefined;
+        const { errorType, suggestion } = getMailErrorDetails(errorMessage);
+        res.status(500).json({
+            success: false,
+            error: 'Mail send test failed',
+            errorType,
+            details: errorDetails ?? errorMessage,
+            suggestion,
+            config: mailConfig.configStatus,
+            runtime: isFlare ? 'Cloudflare Workers' : 'Node',
+            timestamp: new Date().toISOString(),
+        });
+    }
+};

package/routes/TestRoutes.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Register Direct MySQL Test Routes
+ * These routes test packages/db-mysql adapter directly with Cloudflare Workers
+ */
+import type { IRouter } from '../src/routes/Router';
+/**
+ * Register direct MySQL test routes
+ */
+export declare const registerDirectMysqlTestRoutes: (router: IRouter) => void;
+export default registerDirectMysqlTestRoutes;
+//# sourceMappingURL=TestRoutes.d.ts.map

package/routes/TestRoutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestRoutes.d.ts","sourceRoot":"","sources":["../../routes/TestRoutes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAcnD;;GAEG;AACH,eAAO,MAAM,6BAA6B,GAAI,QAAQ,OAAO,KAAG,IAiB/D,CAAC;AAEF,eAAe,6BAA6B,CAAC"}

package/routes/TestRoutes.js

@@ -0,0 +1,25 @@
+/**
+ * Register Direct MySQL Test Routes
+ * These routes test packages/db-mysql adapter directly with Cloudflare Workers
+ */
+import { Router } from '../src/routes/Router.js';
+import { testCacheClear, testCacheDelete, testCacheGet, testCacheHas, testCacheSet, testCacheSmoke, testMailSend, testRedisProxy, testWorkerProcessorUrl, } from './DirectTestRoutes.js';
+/**
+ * Register direct MySQL test routes
+ */
+export const registerDirectMysqlTestRoutes = (router) => {
+    // CRUD operations test
+    Router.get(router, '/test/wg-pr', testRedisProxy);
+    // Processor spec resolution test
+    Router.get(router, '/test/wg-ts', testWorkerProcessorUrl);
+    // Mail send test
+    Router.get(router, '/test/wg-ma', testMailSend);
+    // Cache system (src/cache/Cache.ts) tests
+    Router.get(router, '/test/cache/smoke', testCacheSmoke);
+    Router.get(router, '/test/cache/set', testCacheSet);
+    Router.get(router, '/test/cache/get', testCacheGet);
+    Router.get(router, '/test/cache/has', testCacheHas);
+    Router.get(router, '/test/cache/delete', testCacheDelete);
+    Router.get(router, '/test/cache/clear', testCacheClear);
+};
+export default registerDirectMysqlTestRoutes;

package/routes/api.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Example Routes
+ * Demonstrates routing patterns
+ */
+import { type IRouter } from '../src/routes/Router';
+export declare function registerRoutes(router: IRouter): void;
+//# sourceMappingURL=api.d.ts.map

package/routes/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../routes/api.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,qBAAqB,CAAC;AAQ3D,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAapD"}

package/routes/api.js

@@ -0,0 +1,136 @@
+/**
+ * Example Routes
+ * Demonstrates routing patterns
+ */
+import { AuthController } from '../app/Controllers/AuthController.js';
+import { UserQueryBuilderController } from '../app/Controllers/UserQueryBuilderController.js';
+import { Env } from '../src/config/env.js';
+import { Router } from '../src/routes/Router.js';
+import { registerBroadcastRoutes } from './broadcast.js';
+import { registerStorageRoutes } from './storage.js';
+import { getRuntimeMode } from '../src/runtime/detectRuntime.js';
+import { ErrorFactory } from '../src/index.js';
+export function registerRoutes(router) {
+    try {
+        const authController = AuthController.create();
+        const userController = UserQueryBuilderController.create();
+        registerPublicRoutes(router);
+        registerApiV1Routes(router, authController, userController);
+        registerAdminRoutes(router);
+    }
+    catch (error) {
+        throw ErrorFactory.createConfigError(`Failed to register routes: ${error.message}`, error);
+    }
+}
+/**
+ * Register public routes
+ */
+function registerPublicRoutes(router) {
+    registerRootRoute(router);
+    registerHealthRoute(router);
+    registerBroadcastRoutes(router);
+    registerStorageRoutes(router);
+}
+function registerHealthRoute(router) {
+    Router.get(router, '/health', async (_req, res) => {
+        const modeFromEnv = Env.get('RUNTIME_MODE', '').trim();
+        const mode = modeFromEnv === '' ? getRuntimeMode() : modeFromEnv;
+        res.json({
+            status: 'ok',
+            mode,
+            worker: Env.get('WORKER_ENABLED', 'false') === 'true',
+            timestamp: new Date().toISOString(),
+        });
+    });
+}
+function registerRootRoute(router) {
+    Router.get(router, '/', async (_req, res) => {
+        res.json({
+            framework: 'ZinTrust Framework',
+            app_name: Env.APP_NAME,
+            version: '0.1.41',
+            env: Env.NODE_ENV ?? 'development',
+            database: Env.DB_CONNECTION ?? 'sqlite',
+        });
+    });
+}
+/**
+ * Register API V1 routes
+ */
+function registerApiV1Routes(router, authController, userController) {
+    Router.group(router, '/api/v1', (r) => {
+        // Auth routes
+        Router.post(r, '/auth/login', authController.login, {
+            middleware: ['authRateLimit', 'validateLogin'],
+        });
+        Router.post(r, '/auth/register', authController.register, {
+            middleware: ['authRateLimit', 'validateRegister'],
+        });
+        Router.post(r, '/auth/logout', authController.logout, {
+            middleware: ['auth', 'jwt'],
+        });
+        Router.post(r, '/auth/logout-all', authController.logoutAll, {
+            middleware: ['auth', 'jwt'],
+        });
+        Router.post(r, '/auth/refresh', authController.refresh, {
+            middleware: ['auth', 'jwt'],
+        });
+        // Protected routes (Router supports per-route middleware metadata)
+        const pr = r;
+        // User resource (REST-ish)
+        Router.resource(pr, '/users', {
+            index: userController.index,
+            store: userController.store,
+            show: userController.show,
+            update: userController.update,
+            destroy: userController.destroy,
+        }, {
+            middleware: ['auth', 'bulletproof'],
+            store: {
+                middleware: ['auth', 'bulletproof', 'userMutationRateLimit', 'validateUserStore'],
+            },
+            update: {
+                middleware: ['auth', 'bulletproof', 'userMutationRateLimit', 'validateUserUpdate'],
+            },
+            destroy: { middleware: ['auth', 'bulletproof', 'userMutationRateLimit'] },
+        });
+        Router.post(pr, '/users/fill', userController.fill, {
+            middleware: ['auth', 'jwt', 'fillRateLimit', 'validateUserFill'],
+        });
+        // If the controller exposes create/edit, wire them explicitly.
+        Router.get(pr, '/users/create', userController.create, {
+            middleware: ['auth', 'jwt'],
+        });
+        Router.get(pr, '/users/:id/edit', userController.edit, {
+            middleware: ['auth', 'jwt'],
+        });
+        // Custom user routes
+        Router.get(pr, '/profile', async (__req, res) => {
+            res.json({ message: 'Get user profile' });
+        }, { middleware: ['auth', 'bulletproof'] });
+        Router.put(pr, '/profile', async (__req, res) => {
+            res.json({ message: 'Update user profile' });
+        }, { middleware: ['auth', 'bulletproof'] });
+        // Posts resource
+        Router.get(r, '/posts', async (_req, res) => {
+            res.json({ data: [] });
+        });
+        Router.get(r, '/posts/:id', async (req, res) => {
+            const id = req.getParam('id');
+            res.json({ data: { id } });
+        });
+    });
+}
+/**
+ * Register admin routes
+ */
+function registerAdminRoutes(router) {
+    Router.group(router, '/admin', (r) => {
+        Router.get(r, '/dashboard', async (__req, res) => {
+            res.json({ message: 'Admin dashboard' });
+        });
+        Router.get(r, '/users', async (__req, res) => {
+            res.json({ data: [] });
+        });
+    });
+}

package/routes/apiDev.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Example Routes
+ * Demonstrates routing patterns
+ */
+import { type IRouter } from '../src/routes/Router';
+export declare function registerDevRoutes(_router: IRouter): void;
+//# sourceMappingURL=apiDev.d.ts.map

package/routes/apiDev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiDev.d.ts","sourceRoot":"","sources":["../../routes/apiDev.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,qBAAqB,CAAC;AAqG3D,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAKxD"}