zeti-framework-backend 0.2.8 → 0.2.9

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env bun

package/dist/config-VWgz0Iq_.d.ts

@@ -0,0 +1,647 @@
+import * as hono from 'hono';
+import { Context, Next } from 'hono';
+import Redis, { RedisOptions } from 'ioredis';
+import { HTTPException } from 'hono/http-exception';
+
+/**
+ * Tipo da função do Worker
+ * Recebe o db e opcionalmente o tenantId
+ */
+type WorkerFn = (db: any, tenantId?: string) => Promise<void> | void;
+/**
+ * Configuração de um Worker individual (quando precisa de opções extras)
+ */
+interface WorkerConfigObject {
+    /**
+     * Função que será executada periodicamente
+     */
+    fn: WorkerFn;
+    /**
+     * Intervalo de execução em segundos
+     * @default 30
+     */
+    intervalSeconds?: number;
+    /**
+     * Se true, executa para cada tenant separadamente (multi-tenant)
+     * @default false
+     */
+    multiTenant?: boolean;
+    /**
+     * Se true, executa imediatamente ao iniciar
+     * @default true
+     */
+    runImmediately?: boolean;
+}
+/**
+ * Worker pode ser apenas a função ou um objeto com configurações
+ *
+ * @example Apenas função (usa defaults)
+ * ```typescript
+ * workers: {
+ *   email: emailWorker,
+ * }
+ * ```
+ *
+ * @example Com configurações
+ * ```typescript
+ * workers: {
+ *   email: {
+ *     fn: emailWorker,
+ *     intervalSeconds: 60,
+ *   },
+ * }
+ * ```
+ */
+type WorkerConfig = WorkerFn | WorkerConfigObject;
+/**
+ * Configuração de workers no zetiConfig
+ *
+ * @example
+ * ```typescript
+ * workers: {
+ *   // Apenas a função (usa intervalSeconds: 30 por padrão)
+ *   email: emailWorker,
+ *
+ *   // Com configurações customizadas
+ *   sync: {
+ *     fn: syncWorker,
+ *     intervalSeconds: 60,
+ *     multiTenant: true,
+ *   },
+ * }
+ * ```
+ */
+type WorkersConfig = Record<string, WorkerConfig>;
+
+/**
+ * Redis Client para o Zeti Framework
+ *
+ * Fornece um cliente Redis singleton com configuração flexível
+ * e integração com o ciclo de vida do framework.
+ */
+
+interface RedisConfig {
+    /** URL de conexão Redis (ex: redis://localhost:6379) */
+    url?: string;
+    /** Host do Redis (default: localhost) */
+    host?: string;
+    /** Porta do Redis (default: 6379) */
+    port?: number;
+    /** Senha do Redis */
+    password?: string;
+    /** Número do database (default: 0) */
+    db?: number;
+    /** Prefixo para todas as chaves (ex: 'auth:') */
+    keyPrefix?: string;
+    /** Máximo de retries por request (default: 3) */
+    maxRetriesPerRequest?: number;
+    /** Verificar conexão ao iniciar (default: true) */
+    enableReadyCheck?: boolean;
+    /** Conectar sob demanda (default: false) */
+    lazyConnect?: boolean;
+    /** TLS options */
+    tls?: RedisOptions['tls'];
+}
+/**
+ * Inicializa o cliente Redis com a configuração fornecida.
+ *
+ * **Fail-Fast**: Se o Redis não conseguir conectar, a aplicação falha ao iniciar.
+ * Isso garante que se o Redis está configurado, ele DEVE estar disponível.
+ *
+ * @param config - Configuração do Redis
+ * @returns Promise com a instância do cliente Redis
+ * @throws Error se não conseguir conectar ao Redis
+ */
+declare function initRedis(config: RedisConfig): Promise<Redis>;
+/**
+ * Retorna o cliente Redis singleton.
+ *
+ * @throws Error se o Redis não foi inicializado
+ * @returns Instância do cliente Redis (ioredis)
+ */
+declare function getRedisClient(): Redis;
+/**
+ * Fecha a conexão Redis graciosamente.
+ */
+declare function closeRedis(): Promise<void>;
+/**
+ * Retorna a configuração atual do Redis.
+ */
+declare function getRedisConfig(): RedisConfig | null;
+
+/**
+ * Tipos próprios para Prisma
+ *
+ * Estes tipos são usados para evitar dependência direta de @prisma/client
+ * durante o build da biblioteca, já que Prisma é uma peer dependency.
+ *
+ * O usuário passa o PrismaClient real como generic, então o TypeScript
+ * vai inferir os tipos corretos em tempo de uso.
+ */
+type PrismaClientBase = {
+    $connect: () => Promise<void>;
+    $disconnect: () => Promise<void>;
+    $transaction: <T>(fn: (client: any) => Promise<T>) => Promise<T>;
+    $queryRaw: any;
+    $executeRaw: any;
+    [key: string]: any;
+};
+declare namespace Prisma {
+    interface PrismaClientKnownRequestError extends Error {
+        code: string;
+        meta?: any;
+        clientVersion?: string;
+    }
+    interface PrismaClientValidationError extends Error {
+        message: string;
+    }
+    interface PrismaClientInitializationError extends Error {
+        errorCode?: string;
+        clientVersion?: string;
+    }
+    interface PrismaClientRustPanicError extends Error {
+        requestId?: string;
+        clientVersion?: string;
+    }
+    type PrismaClientError = PrismaClientKnownRequestError | PrismaClientValidationError | PrismaClientInitializationError | PrismaClientRustPanicError;
+}
+
+interface ValidationError {
+    field: string;
+    errors: string[];
+}
+interface ErrorTrace {
+    path: string;
+    method: string;
+    timestamp: string;
+    errorType: string;
+    stack?: string;
+}
+interface ErrorResponse {
+    data: null;
+    status: number;
+    message: string;
+    validationErrors?: Record<string, {
+        errors: string[];
+    }>;
+    trace?: ErrorTrace;
+}
+interface ZetiErrorHandlerConfig {
+    formatError?: (error: any, context: Context) => ErrorResponse;
+    logError?: (error: any, context: Context) => void;
+    /** Incluir trace de erro na resposta (default: true em dev, false em prod) */
+    includeTrace?: boolean;
+    /** Incluir stack trace na resposta (default: false) */
+    includeStack?: boolean;
+}
+declare function createErrorHandler(config?: ZetiErrorHandlerConfig): (c: Context, next: () => Promise<void>) => Promise<(Response & hono.TypedResponse<{
+    data: null;
+    status: number;
+    message: string;
+    validationErrors?: {
+        [x: string]: {
+            errors: string[];
+        };
+    } | undefined;
+    trace?: {
+        path: string;
+        method: string;
+        timestamp: string;
+        errorType: string;
+        stack?: string | undefined;
+    } | undefined;
+}, any, "json">) | undefined>;
+declare function handleError(exception: Error | HTTPException | Prisma.PrismaClientKnownRequestError | ValidationError[] | any, config?: ZetiErrorHandlerConfig, trace?: ErrorTrace, context?: {
+    tenant?: string;
+}): ErrorResponse;
+
+type Middleware = (c: Context, next: Next) => Promise<Response | void> | Response | void;
+interface ZetiDatabaseConfig {
+    /**
+     * Conexões de banco de dados.
+     *
+     * Para single-tenant: { default: "connection_string" }
+     * Para multi-tenant: { tenantName: "connection_string", ... }
+     *
+     * O valor do header x-tenant (ou headerName configurado) é usado como chave.
+     *
+     * @example
+     * ```typescript
+     * connections: {
+     *   mulherdevalor: env("TENANT_MULHERDEVALOR_DATABASE_URL"),
+     *   outroTenant: env("TENANT_OUTRO_DATABASE_URL"),
+     * }
+     * ```
+     */
+    connections: Record<string, string>;
+    /**
+     * Resolver dinâmico para conexões não encontradas em `connections`.
+     * Útil para cenários onde os tenants são criados dinamicamente.
+     */
+    resolver?: (tenantId: string) => Promise<string> | string;
+    /** Configuração de cache de conexões */
+    cache?: {
+        maxClients?: number;
+        ttl?: number;
+        cleanupInterval?: number;
+    };
+}
+interface ZetiPrismaConfig {
+    adapter?: 'pg' | 'mysql' | 'sqlite' | 'custom';
+    logLevel?: ('query' | 'error' | 'warn')[];
+    connectionPool?: {
+        max?: number;
+        min?: number;
+        idleTimeoutMillis?: number;
+        connectionTimeoutMillis?: number;
+    };
+}
+/**
+ * Estratégia de conexão com o banco de dados.
+ *
+ * - `single`: Usa DATABASE_URL único, zero overhead de multi-tenancy
+ * - `dynamic`: Usa tenantSelector para resolver URL e tenantId por request
+ */
+type ConnectionStrategy = 'single' | 'dynamic';
+/**
+ * Resultado do tenantSelector.
+ *
+ * @example Row-level isolation (mesmo banco)
+ * ```typescript
+ * { tenantId: 'abc-123' }
+ * ```
+ *
+ * @example Database sharding (bancos diferentes)
+ * ```typescript
+ * { databaseUrl: process.env.DB_TENANT_A }
+ * ```
+ *
+ * @example Combinado
+ * ```typescript
+ * { tenantId: 'abc-123', databaseUrl: process.env.DB_TENANT_A }
+ * ```
+ */
+interface TenantSelection {
+    /** ID do tenant para filtro automático via $extends */
+    tenantId?: string;
+    /** URL do banco de dados (se diferente de DATABASE_URL) */
+    databaseUrl?: string;
+}
+/**
+ * Escopo de segurança definido pelo middleware.
+ *
+ * Quando definido via `context.set('securityScope', scope)`, o framework
+ * automaticamente aplica validações em todas as operações do Prisma:
+ *
+ * - **Leitura**: Adiciona campos ao WHERE (filtro automático)
+ * - **Criação**: VALIDA que os campos passados correspondem ao escopo
+ * - **Atualização/Deleção**: Adiciona campos ao WHERE (proteção)
+ *
+ * @example No middleware
+ * ```typescript
+ * context.set('securityScope', {
+ *   tenantId: tenant.id,
+ *   productId: product.id,
+ * });
+ * ```
+ *
+ * @example No controller (proteção automática)
+ * ```typescript
+ * // Isso vai FALHAR se tenantId for diferente do escopo:
+ * await db.role.create({ data: { name: 'Admin', tenantId: 'outro-tenant' } });
+ * // Error: [Zeti Security] Campo 'tenantId' inválido...
+ *
+ * // Isso funciona:
+ * await db.role.create({ data: { name: 'Admin', tenantId: scopeTenantId } });
+ * ```
+ */
+interface SecurityScope {
+    /** ID do tenant - obrigatório em creates, filtrado em reads */
+    tenantId?: string;
+    /** ID do produto - obrigatório em creates, filtrado em reads */
+    productId?: string;
+    /** Campos adicionais customizados */
+    [key: string]: string | undefined;
+}
+/**
+ * Configuração de conexão do Prisma com suporte a multi-tenancy.
+ *
+ * @example Single database (app simples)
+ * ```typescript
+ * prisma: {
+ *   client: PrismaClient,
+ *   connectionStrategy: 'single',
+ * }
+ * ```
+ *
+ * @example Multi-tenant com row-level isolation
+ * ```typescript
+ * prisma: {
+ *   client: PrismaClient,
+ *   connectionStrategy: 'dynamic',
+ *   tenantSelector: (context) => ({
+ *     tenantId: context.req.header('x-tenant-id'),
+ *   }),
+ * }
+ * ```
+ *
+ * @example Multi-database (sharding)
+ * ```typescript
+ * prisma: {
+ *   client: PrismaClient,
+ *   connectionStrategy: 'dynamic',
+ *   tenantSelector: (context) => {
+ *     const product = context.req.header('x-product-name');
+ *     return {
+ *       tenantId: context.req.header('x-tenant-id'),
+ *       databaseUrl: process.env[`DB_${product?.toUpperCase()}`],
+ *     };
+ *   },
+ * }
+ * ```
+ */
+interface ZetiPrismaConnectionConfig<TPrisma = any> {
+    /** Classe do PrismaClient do projeto */
+    client: new (...args: any[]) => TPrisma;
+    /**
+     * Estratégia de conexão.
+     * - `single`: Usa DATABASE_URL, sem multi-tenancy
+     * - `dynamic`: Usa tenantSelector para resolver conexão
+     * @default 'single'
+     */
+    connectionStrategy?: ConnectionStrategy;
+    /**
+     * Função que resolve tenantId e/ou databaseUrl por request.
+     * Obrigatório se connectionStrategy = 'dynamic'.
+     */
+    tenantSelector?: (context: Context) => TenantSelection | Promise<TenantSelection>;
+    /**
+     * Extension customizada aplicada após o filtro de tenant.
+     * Permite encadear $extends adicionais.
+     */
+    customExtension?: (baseClient: TPrisma, selection: TenantSelection) => TPrisma;
+}
+interface ZetiCorsConfig {
+    enabled?: boolean;
+    origin?: string | string[] | ((origin: string) => boolean);
+    allowMethods?: string[];
+    allowHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+}
+interface ZetiSwaggerHeaderParam {
+    name: string;
+    description?: string;
+    required?: boolean;
+    example?: string;
+}
+interface ZetiSwaggerConfig {
+    enabled?: boolean;
+    title: string;
+    version?: string;
+    description?: string;
+    servers?: Array<{
+        url: string;
+        description?: string;
+    }>;
+    outputPath?: string;
+    generateOnBuild?: boolean;
+    uiPath?: string;
+    docPath?: string;
+    globalHeaders?: ZetiSwaggerHeaderParam[];
+}
+/**
+ * Configuração de headers customizados.
+ *
+ * Cada header declarado aqui:
+ * - Será acessível via `c.req.header(name)`
+ * - Aparecerá automaticamente como parâmetro opcional no Swagger
+ *
+ * @example
+ * ```typescript
+ * headers: {
+ *   tenant: "x-tenant",           // Header para multi-tenancy
+ *   timezone: "timezone",         // Header de timezone
+ *   apiKey: "x-internal-api-key", // Header customizado
+ * }
+ * ```
+ */
+interface ZetiHeadersConfig {
+    /** Header de tenant para multi-tenancy. Default: "x-tenant" */
+    tenant?: string;
+    /** Header de timezone. Default: "timezone" */
+    timezone?: string;
+    /** Permite qualquer header customizado adicional */
+    [key: string]: string | undefined;
+}
+interface ZetiTenantConfig {
+    enabled?: boolean;
+    required?: boolean;
+    headerName?: string;
+    defaultDatabase?: string;
+}
+interface ZetiMiddlewareConfig {
+    global?: Middleware[];
+    named?: Record<string, Middleware | ((...args: any[]) => Middleware)>;
+}
+/** Configuração de desenvolvimento do projeto */
+interface ZetiDevConfig {
+    /** Porta do servidor. Default: 3333 */
+    port?: number;
+    /** Caminho do docker-compose. Default: "../infra/local/docker-compose.yaml" */
+    dockerCompose?: string;
+    /** Portas para limpar antes de iniciar. Default: [3333, 5432] */
+    ports?: number[];
+    /** Configuração do framework local (para desenvolvimento) */
+    framework?: {
+        /** Caminho do framework. Default: "../_developer/_npm" */
+        path?: string;
+        /** Observar mudanças no framework. Default: true */
+        watch?: boolean;
+    };
+}
+
+/** Configuração interna completa do Zeti (após normalização) */
+interface ZetiConfigInternal<TPrisma = any> {
+    databases: ZetiDatabaseConfig;
+    specialDatabases?: Record<string, string>;
+    prisma: ZetiPrismaConfig;
+    /** Nova configuração de conexão Prisma com modos de operação */
+    prismaConnection?: ZetiPrismaConnectionConfig<TPrisma>;
+    swagger: Required<Omit<ZetiSwaggerConfig, 'globalHeaders' | 'description'>> & {
+        globalHeaders?: ZetiSwaggerHeaderParam[];
+        description?: string;
+    };
+    tenant?: ZetiTenantConfig;
+    cors: Required<Omit<ZetiCorsConfig, 'maxAge'>> & {
+        maxAge?: number;
+    };
+    logger: boolean;
+    debug: boolean;
+    headers?: ZetiHeadersConfig;
+    middlewares: ZetiMiddlewareConfig;
+    errorHandler: ZetiErrorHandlerConfig | boolean;
+    hooks?: {
+        onRouteRegister?: (route: any) => void;
+        onRequest?: (context: any) => void | Promise<void>;
+        onResponse?: (context: any, response: any) => any;
+    };
+    dev: Required<ZetiDevConfig>;
+    workers?: WorkersConfig;
+}
+/**
+ * Configuração do Zeti Framework.
+ *
+ * A maioria das opções tem defaults sensatos - você só precisa configurar o que for diferente.
+ *
+ * @example Configuração mínima
+ * ```typescript
+ * defineZetiConfig({
+ *   swagger: { title: "My API" },
+ * });
+ * ```
+ */
+interface ZetiConfig {
+    /**
+     * URL de conexão do banco de dados (para apps single-tenant).
+     * Se não informado, usa DATABASE_URL do .env automaticamente.
+     */
+    databaseUrl?: string;
+    /**
+     * Configuração de databases (para apps multi-tenant).
+     * Se não informado, o framework usa databaseUrl ou DATABASE_URL do .env.
+     */
+    databases?: ZetiDatabaseConfig;
+    specialDatabases?: Record<string, string>;
+    /** Configuração do Prisma. Opcional - usa defaults sensatos. */
+    prisma?: ZetiPrismaConfig;
+    /**
+     * Configuração do Swagger. Apenas `title` é obrigatório.
+     * Defaults: enabled=true, version="1.0.0", uiPath="/swagger", docPath="/swagger/doc"
+     */
+    swagger: {
+        /** Título da API (obrigatório) */
+        title: string;
+        /** Versão da API. Default: "1.0.0" */
+        version?: string;
+        /** Descrição da API */
+        description?: string;
+        /** Servidores. Default: [{ url: "http://localhost:{port}" }] */
+        servers?: Array<{
+            url: string;
+            description?: string;
+        }>;
+        /** Habilitar Swagger UI. Default: true */
+        enabled?: boolean;
+        /** Caminho do arquivo de schemas. Default: "./.zeti/generated/swagger-schemas.ts" */
+        outputPath?: string;
+        /** Gerar schemas no build. Default: true */
+        generateOnBuild?: boolean;
+        /** Caminho da UI. Default: "/swagger" */
+        uiPath?: string;
+        /** Caminho do JSON. Default: "/swagger/doc" */
+        docPath?: string;
+        /** Headers globais */
+        globalHeaders?: ZetiSwaggerHeaderParam[];
+    };
+    /** Configuração de multi-tenancy. Se não informado, tenant fica desabilitado. */
+    tenant?: ZetiTenantConfig;
+    /**
+     * Configuração de CORS. Opcional - usa defaults permissivos para desenvolvimento.
+     * Defaults: enabled=true, origin="*", credentials=true, allowHeaders=["*"]
+     */
+    cors?: ZetiCorsConfig;
+    /** Habilitar logger de requisições. Default: true */
+    logger?: boolean;
+    /** Habilitar logs de debug. Default: false */
+    debug?: boolean;
+    /** Configuração de headers customizados */
+    headers?: ZetiHeadersConfig;
+    /** Configuração de middlewares */
+    middlewares?: ZetiMiddlewareConfig;
+    /** Configuração do error handler. Default: {} (habilitado com defaults) */
+    errorHandler?: ZetiErrorHandlerConfig | boolean;
+    /** Hooks do ciclo de vida */
+    hooks?: {
+        onRouteRegister?: (route: any) => void;
+        onRequest?: (context: any) => void | Promise<void>;
+        onResponse?: (context: any, response: any) => any;
+    };
+    /**
+     * Configuração de desenvolvimento (usado pelo CLI `zeti dev`).
+     * Opcional - usa defaults sensatos.
+     */
+    dev?: ZetiDevConfig;
+    /**
+     * Workers que serão iniciados automaticamente com o servidor.
+     *
+     * @example
+     * ```typescript
+     * workers: {
+     *   email: {
+     *     fn: async (db) => {
+     *       const emails = await db.email.findMany({ where: { status: 'PENDING' } });
+     *       // processar...
+     *     },
+     *     intervalSeconds: 30,
+     *   },
+     *   sync: {
+     *     fn: async (db, tenantId) => {
+     *       // sincroniza dados do tenant
+     *     },
+     *     intervalSeconds: 60,
+     *     multiTenant: true,
+     *   },
+     * }
+     * ```
+     */
+    workers?: WorkersConfig;
+    /**
+     * Configuração do Redis.
+     *
+     * Se fornecido, o cliente Redis será inicializado automaticamente
+     * e disponibilizado via `import { redis } from '@zeti/app'`.
+     *
+     * @example
+     * ```typescript
+     * redis: {
+     *   host: process.env.REDIS_HOST ?? 'localhost',
+     *   port: parseInt(process.env.REDIS_PORT ?? '6379'),
+     *   keyPrefix: 'myapp:',
+     * }
+     * ```
+     */
+    redis?: RedisConfig;
+}
+
+/**
+ * Define a configuração do Zeti Framework.
+ *
+ * Detecta automaticamente se é single-tenant ou multi-tenant e aplica defaults sensatos.
+ *
+ * @example Configuração mínima (single-tenant)
+ * ```typescript
+ * export const zetiConfig = defineZetiConfig({
+ *   swagger: { title: "My API" },
+ * });
+ * ```
+ *
+ * @example Multi-tenant
+ * ```typescript
+ * export const zetiConfig = defineZetiConfig({
+ *   databases: {
+ *     connections: {
+ *       mulherdevalor: env("TENANT_MULHERDEVALOR_DATABASE_URL"),
+ *       outroTenant: env("TENANT_OUTRO_DATABASE_URL"),
+ *     },
+ *   },
+ *   tenant: { enabled: true, required: true },
+ *   swagger: { title: "Multi-tenant API" },
+ * });
+ * ```
+ */
+declare function defineZetiConfig(config: ZetiConfig, options?: {
+    port?: number;
+}): ZetiConfigInternal;
+
+export { type ConnectionStrategy as C, type ErrorResponse as E, type Middleware as M, Prisma as P, type RedisConfig as R, type SecurityScope as S, type TenantSelection as T, type ValidationError as V, type WorkerConfig as W, type ZetiSwaggerConfig as Z, type ZetiConfigInternal as a, type ZetiPrismaConnectionConfig as b, type ErrorTrace as c, type PrismaClientBase as d, type WorkersConfig as e, type ZetiConfig as f, type ZetiCorsConfig as g, type ZetiDatabaseConfig as h, type ZetiDevConfig as i, type ZetiErrorHandlerConfig as j, type ZetiHeadersConfig as k, type ZetiMiddlewareConfig as l, type ZetiPrismaConfig as m, type ZetiSwaggerHeaderParam as n, type ZetiTenantConfig as o, closeRedis as p, createErrorHandler as q, defineZetiConfig as r, getRedisClient as s, getRedisConfig as t, handleError as u, initRedis as v };

package/dist/generator-CK-ZmWQj.d.ts

@@ -0,0 +1,197 @@
+import { ZodRawShape, ZodTypeAny, ZodObject, z } from 'zod';
+import { Context, Next } from 'hono';
+import { Z as ZetiSwaggerConfig } from './config-VWgz0Iq_.js';
+
+/**
+ * Handler de middleware com db injetado automaticamente.
+ *
+ * O `db` é obtido do contexto (setado pelo framework) e já vem com:
+ * - Filtro de tenant aplicado (se connectionStrategy = 'dynamic')
+ * - Cache por URL (reutiliza instância base)
+ */
+type MiddlewareHandler<TDb = any> = (c: Context, next: Next, db: TDb) => Promise<void | Response>;
+/**
+ * Cria um middleware com o `db` injetado automaticamente.
+ *
+ * O `db` é obtido do contexto (setado pelo framework) e já vem com:
+ * - Filtro de tenant aplicado (se connectionStrategy = 'dynamic')
+ * - Cache por URL (reutiliza instância base)
+ *
+ * @example
+ * ```typescript
+ * import { PrismaClient } from '@prisma/client';
+ *
+ * const authMiddleware = createMiddleware<PrismaClient>(async (c, next, db) => {
+ *   // db já vem tipado e com filtro de tenant
+ *   const user = await db.user.findUnique({
+ *     where: { id: c.req.header('x-user-id') }
+ *   });
+ *
+ *   if (!user) {
+ *     return c.json({ error: 'Unauthorized' }, 401);
+ *   }
+ *
+ *   c.set('user', user);
+ *   await next();
+ * });
+ * ```
+ */
+declare function createMiddleware<TDb = any>(handler: MiddlewareHandler<TDb>): (c: Context, next: Next) => Promise<void | Response>;
+type MiddlewareFactory<T extends any[], TDb = any> = (...args: T) => (c: Context, next: Next) => Promise<void | Response>;
+/**
+ * Cria uma factory de middleware com db injetado.
+ *
+ * @example
+ * ```typescript
+ * const requirePermission = createMiddlewareFactory<[string[]], PrismaClient>(
+ *   (permissions: string[]) => async (c, next, db) => {
+ *     const user = c.get('user');
+ *     const userPermissions = await db.permission.findMany({
+ *       where: { userId: user.id }
+ *     });
+ *
+ *     const hasPermission = permissions.every(p =>
+ *       userPermissions.some(up => up.name === p)
+ *     );
+ *
+ *     if (!hasPermission) {
+ *       return c.json({ error: 'Forbidden' }, 403);
+ *     }
+ *
+ *     await next();
+ *   }
+ * );
+ *
+ * // Uso:
+ * app.use('/admin/*', requirePermission(['admin:read']));
+ * ```
+ */
+declare function createMiddlewareFactory<T extends any[], TDb = any>(factory: (...args: T) => MiddlewareHandler<TDb>): MiddlewareFactory<T, TDb>;
+/**
+ * Helper para obter o db do contexto de forma tipada.
+ * Útil quando você precisa acessar o db fora do createMiddleware.
+ *
+ * @throws Error se o db não estiver disponível
+ *
+ * @example
+ * ```typescript
+ * // Em um handler de rota Hono puro
+ * app.get('/users', async (c) => {
+ *   const db = getDb<PrismaClient>(c);
+ *   const users = await db.user.findMany();
+ *   return c.json(users);
+ * });
+ * ```
+ */
+declare function getDb<TDb = any>(c: Context): TDb;
+/**
+ * Helper para obter o db do contexto de forma segura (pode retornar undefined).
+ *
+ * @example
+ * ```typescript
+ * // Em um handler de rota Hono puro
+ * app.get('/health', async (c) => {
+ *   const db = getDbSafe<PrismaClient>(c);
+ *   if (!db) {
+ *     return c.json({ status: 'degraded', db: false });
+ *   }
+ *   return c.json({ status: 'ok', db: true });
+ * });
+ * ```
+ */
+declare function getDbSafe<TDb = any>(c: Context): TDb | undefined;
+
+type SchemaDefinition = {
+    body?: ZodRawShape | ZodTypeAny;
+    query?: ZodRawShape | ZodTypeAny;
+    response?: ZodRawShape | ZodTypeAny;
+    formData?: ZodRawShape | ZodTypeAny;
+};
+type NormalizeFormData<T> = T extends ZodTypeAny ? T : T extends ZodRawShape ? ZodObject<T> : never;
+type InferFormData<S extends SchemaDefinition> = S['formData'] extends undefined ? unknown : NormalizeFormData<S['formData']> extends never ? unknown : z.infer<NormalizeFormData<S['formData']>>;
+type NormalizeZod<T> = T extends ZodTypeAny ? T : T extends ZodRawShape ? ZodObject<T> : never;
+type InferBody<S extends SchemaDefinition> = S['body'] extends undefined ? unknown : NormalizeZod<S['body']> extends never ? unknown : z.infer<NormalizeZod<S['body']>>;
+type InferQuery<S extends SchemaDefinition> = S['query'] extends undefined ? unknown : NormalizeZod<S['query']> extends never ? unknown : z.infer<NormalizeZod<S['query']>>;
+type ExtractParams<T extends string> = T extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
+    [K in Param]: string;
+} & ExtractParams<Rest> : T extends `${infer _Start}:${infer Param}` ? {
+    [K in Param]: string;
+} : {};
+type ZetiZod = typeof z;
+type ZetiContextExtensions = {
+    ipAddress?: string;
+    userAgent?: string;
+    timezone: string;
+    tenantId: string;
+};
+type ZetiContext<TContext extends Context = Context> = TContext & ZetiContextExtensions;
+interface ZetiRouteProps<TParams extends Record<string, string>, TBody, TQuery, TFormData, TPrisma = any, TUser = any> {
+    context: ZetiContext;
+    next: Next;
+    params: TParams;
+    body: TBody;
+    query: TQuery;
+    formData: TFormData;
+    user?: TUser;
+    db: TPrisma;
+    res: ZetiResponseHelpers;
+}
+interface ZetiResponseHelpers {
+    goneError: (params: {
+        message: string;
+        code?: string;
+    }) => never;
+    unauthorizedError: (message: string) => never;
+    badRequestError: (message: string) => never;
+}
+interface ZetiMethodOptions<TPath extends string, TSchema extends SchemaDefinition, TPrisma = any, TUser = any> {
+    middleware?: {
+        use?: MiddlewareHandler[];
+        schema?: (z: ZetiZod) => TSchema;
+        database?: string;
+        tenant?: boolean;
+        /** Exige auth (injeta `auth` antes dos demais). */
+        auth?: boolean;
+        /** Claims exigidas (usa `requireClaim` de named). */
+        claims?: string[];
+        /** Roles exigidas (usa `requireRole` de named). */
+        roles?: string[];
+    };
+    route: (props: ZetiRouteProps<ExtractParams<TPath>, InferBody<TSchema>, InferQuery<TSchema>, InferFormData<TSchema>, TPrisma, TUser>) => Promise<any>;
+}
+interface RouteMetadata {
+    path: string;
+    method: 'get' | 'post' | 'put' | 'delete' | 'patch';
+    auth: boolean;
+    tenant?: boolean;
+    claims?: string[];
+    roles?: string[];
+    bodySchema?: ZodTypeAny;
+    querySchema?: ZodTypeAny;
+    responseSchema?: ZodTypeAny;
+    formDataSchema?: ZodTypeAny;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+}
+type ZetiRouteMiddleware<TSchema extends SchemaDefinition> = ZetiMethodOptions<any, TSchema>['middleware'];
+
+declare class SwaggerRegistry {
+    private routes;
+    register(metadata: RouteMetadata): void;
+    getAll(): RouteMetadata[];
+    clear(): void;
+}
+
+interface SwaggerGeneratorOptions {
+    loadGeneratedSchemas?: () => Promise<{
+        routeResponseSchemas?: Record<string, Record<string, {
+            schema: ZodTypeAny;
+            ref: string | null;
+        }>>;
+        namedSchemas?: Record<string, ZodTypeAny>;
+    }>;
+}
+declare function generateSwagger(registry: SwaggerRegistry, config: ZetiSwaggerConfig, options?: SwaggerGeneratorOptions): Promise<object>;
+
+export { type ExtractParams as E, type InferBody as I, type MiddlewareFactory as M, type RouteMetadata as R, type SwaggerGeneratorOptions as S, type ZetiMethodOptions as Z, SwaggerRegistry as a, type SchemaDefinition as b, type InferFormData as c, type InferQuery as d, type MiddlewareHandler as e, type ZetiContext as f, generateSwagger as g, type ZetiContextExtensions as h, type ZetiResponseHelpers as i, type ZetiRouteMiddleware as j, type ZetiRouteProps as k, type ZetiZod as l, createMiddleware as m, createMiddlewareFactory as n, getDb as o, getDbSafe as p };

package/dist/index.d.ts

@@ -0,0 +1,281 @@
+import * as hono_types from 'hono/types';
+import { Context, Next, Hono } from 'hono';
+import { a as ZetiConfigInternal, W as WorkerConfig, b as ZetiPrismaConnectionConfig, R as RedisConfig } from './config-VWgz0Iq_.js';
+export { C as ConnectionStrategy, E as ErrorResponse, c as ErrorTrace, M as Middleware, P as Prisma, d as PrismaClientBase, S as SecurityScope, T as TenantSelection, V as ValidationError, e as WorkersConfig, f as ZetiConfig, g as ZetiCorsConfig, h as ZetiDatabaseConfig, i as ZetiDevConfig, j as ZetiErrorHandlerConfig, k as ZetiHeadersConfig, l as ZetiMiddlewareConfig, m as ZetiPrismaConfig, Z as ZetiSwaggerConfig, n as ZetiSwaggerHeaderParam, o as ZetiTenantConfig, p as closeRedis, q as createErrorHandler, r as defineZetiConfig, s as getRedisClient, t as getRedisConfig, u as handleError, v as initRedis } from './config-VWgz0Iq_.js';
+import { b as SchemaDefinition, Z as ZetiMethodOptions, a as SwaggerRegistry } from './generator-CK-ZmWQj.js';
+export { E as ExtractParams, I as InferBody, c as InferFormData, d as InferQuery, M as MiddlewareFactory, e as MiddlewareHandler, R as RouteMetadata, S as SwaggerGeneratorOptions, f as ZetiContext, h as ZetiContextExtensions, i as ZetiResponseHelpers, j as ZetiRouteMiddleware, k as ZetiRouteProps, l as ZetiZod, m as createMiddleware, n as createMiddlewareFactory, g as generateSwagger, o as getDb, p as getDbSafe } from './generator-CK-ZmWQj.js';
+import { TenantManager } from './tenants/index.js';
+export { MetricsCollector, TenantMetrics } from './tenants/index.js';
+import Redis from 'ioredis';
+export { default as Redis } from 'ioredis';
+export { PrismaConfigOptions, definePrismaConfig, getAllDatabaseUrls } from './prisma/index.js';
+import { z } from 'zod';
+export { GenerateRegistryOptions, GenerateSwaggerTypesOptions, generateRegistry, generateSwaggerTypes, runPrebuild } from './scripts/index.js';
+import 'hono/http-exception';
+
+/**
+ * Handler de middleware tipado com o PrismaClient do projeto.
+ */
+type ZetiMiddlewareHandler<TPrisma = any> = (c: Context, next: Next, db: TPrisma) => Promise<void | Response>;
+interface ZetiApp<TPrisma = any, TUser = any> {
+    get: <TPath extends string, TSchema extends SchemaDefinition = {}>(url: TPath, options: ZetiMethodOptions<TPath, TSchema, TPrisma, TUser>) => void;
+    post: <TPath extends string, TSchema extends SchemaDefinition = {}>(url: TPath, options: ZetiMethodOptions<TPath, TSchema, TPrisma, TUser>) => void;
+    put: <TPath extends string, TSchema extends SchemaDefinition = {}>(url: TPath, options: ZetiMethodOptions<TPath, TSchema, TPrisma, TUser>) => void;
+    del: <TPath extends string, TSchema extends SchemaDefinition = {}>(url: TPath, options: ZetiMethodOptions<TPath, TSchema, TPrisma, TUser>) => void;
+    patch: <TPath extends string, TSchema extends SchemaDefinition = {}>(url: TPath, options: ZetiMethodOptions<TPath, TSchema, TPrisma, TUser>) => void;
+    /**
+     * Cria um middleware com o db tipado automaticamente.
+     *
+     * @example
+     * ```typescript
+     * const authMiddleware = app.createMiddleware(async (c, next, db) => {
+     *   const user = await db.user.findUnique({
+     *     where: { id: c.req.header('x-user-id') }
+     *   });
+     *   if (!user) return c.json({ error: 'Unauthorized' }, 401);
+     *   c.set('user', user);
+     *   await next();
+     * });
+     * ```
+     */
+    createMiddleware: (handler: ZetiMiddlewareHandler<TPrisma>) => (c: Context, next: Next) => Promise<void | Response>;
+    honoApp: Hono;
+    swaggerRegistry: SwaggerRegistry;
+    tenantManager: TenantManager;
+    shutdown: () => Promise<void>;
+}
+/**
+ * Cria uma instância do Zeti App
+ *
+ * @template TPrisma - Tipo do PrismaClient do projeto do usuário
+ * @template TUser - Tipo do usuário autenticado (opcional)
+ *
+ * @example
+ * ```typescript
+ * import { PrismaClient } from '@prisma/client';
+ *
+ * const app = createZetiApp<PrismaClient>({
+ *   config,
+ *   prismaClient: PrismaClient,
+ * });
+ *
+ * // Agora todas as rotas terão db tipado como PrismaClient do usuário
+ * app.get('/users', {
+ *   route: async ({ db }) => {
+ *     // db é tipado como PrismaClient do usuário
+ *     // Com todos os modelos do schema.prisma
+ *     const users = await db.user.findMany();
+ *     return { data: users };
+ *   },
+ * });
+ * ```
+ */
+declare function createZetiApp<TPrisma = any, TUser = any>(options: {
+    config: ZetiConfigInternal;
+    prismaClient: new (...args: any[]) => TPrisma;
+}): ZetiApp<TPrisma, TUser>;
+declare function initializeZetiApp<TPrisma = any, TUser = any>(options: {
+    config: ZetiConfigInternal;
+    prismaClient: new (...args: any[]) => TPrisma;
+}): ZetiApp<TPrisma, TUser>;
+declare function getZetiApp(): ZetiApp<any, any> | null;
+declare function getZetiAppTyped<TPrisma = any, TUser = any>(): ZetiApp<TPrisma, TUser>;
+declare function autoInitializeZetiApp<TPrisma = any, TUser = any>(options?: {
+    configPath?: string;
+    prismaClient?: new (...args: any[]) => TPrisma;
+}): Promise<ZetiApp<TPrisma, TUser> | null>;
+declare const honoRoutesZeti: Hono<hono_types.BlankEnv, hono_types.BlankSchema, "/">;
+
+/**
+ * Função para obter conexão do banco
+ * Para multi-tenant, recebe o tenantId e retorna o banco do tenant
+ */
+type GetDbFn = (tenantId?: string) => any | Promise<any>;
+/**
+ * Instância de um Worker em execução
+ */
+declare class WorkerInstance {
+    private name;
+    private config;
+    private intervalId;
+    private isRunning;
+    private isProcessing;
+    private isStopping;
+    private getDb;
+    private getTenants?;
+    private executionCount;
+    private startedAt;
+    constructor(name: string, config: WorkerConfig, getDb: GetDbFn, getTenants?: () => string[]);
+    start(): void;
+    /**
+     * Para o worker de forma graciosa, aguardando execução atual terminar
+     */
+    stop(): Promise<void>;
+    /**
+     * Verifica se está processando
+     */
+    getIsProcessing(): boolean;
+    private run;
+}
+/**
+ * Gerenciador de Workers com Graceful Shutdown
+ */
+declare class WorkerManager {
+    private workers;
+    private isShuttingDown;
+    constructor();
+    /**
+     * Configura listeners para sinais de shutdown
+     */
+    private setupGracefulShutdown;
+    startAll(workersConfig: Record<string, WorkerConfig>, getDb: GetDbFn, getTenants?: () => string[]): void;
+    /**
+     * Para todos os workers de forma graciosa
+     */
+    stopAll(): Promise<void>;
+    /**
+     * Para um worker específico
+     */
+    stop(name: string): Promise<void>;
+    getActiveWorkers(): string[];
+    /**
+     * Verifica se algum worker está processando
+     */
+    hasActiveProcessing(): boolean;
+}
+
+interface StartZetiOptions<TPrisma = any, TUser = any> {
+    config: ZetiConfigInternal;
+    prisma?: ZetiPrismaConnectionConfig<TPrisma>;
+    redis?: RedisConfig;
+    port?: number;
+    registryPath?: string;
+    onReady?: (app: ZetiApp<TPrisma, TUser>) => void | Promise<void>;
+}
+declare function startZeti<TPrisma = any, TUser = any>(options: StartZetiOptions<TPrisma, TUser>): Promise<ZetiApp<TPrisma, TUser>>;
+declare function getPrismaClient<TPrisma = any>(tenantId?: string): TPrisma;
+declare function createAppProxy<TPrisma = any, TUser = any>(): ZetiApp<TPrisma, TUser>;
+declare function getPrismaConnectionConfig(): ZetiPrismaConnectionConfig | null;
+declare function getWorkerManager(): WorkerManager | null;
+declare function stopAllWorkers(): void;
+declare function getRedis(): Redis;
+declare function hasRedis(): boolean;
+declare function getRedisConfiguration(): RedisConfig | null;
+declare function shutdownZeti(): Promise<void>;
+
+declare function badRequestError(message: string, cause?: any): never;
+declare function unauthorizedError(message: string, cause?: any): never;
+declare function forbiddenError(message: string, cause?: any): never;
+declare function notFoundError(message: string, cause?: any): never;
+declare function conflictError(message: string, cause?: any): never;
+declare function goneError(message: string, cause?: any): never;
+declare function unprocessableEntityError(message: string, cause?: any): never;
+declare function internalServerError(message: string, cause?: any): never;
+
+declare function loadEnv(): void;
+/**
+ * Retorna o valor de uma variável de ambiente.
+ *
+ * @param key - Nome da variável de ambiente
+ * @param fallback - Valor padrão se a variável não existir (padrão: undefined = obrigatório)
+ * @returns O valor da variável ou o fallback
+ * @throws Error se a variável não existir e não houver fallback
+ *
+ * @example
+ * ```typescript
+ * // Obrigatório - lança erro se não existir
+ * const dbUrl = env("DATABASE_URL");
+ *
+ * // Opcional - retorna fallback
+ * const port = env("PORT", "3000");
+ * ```
+ */
+declare function env(key: string, fallback?: string): string;
+
+/**
+ * Symbol usado para identificar schemas de arquivo
+ */
+declare const FILE_SCHEMA_SYMBOL: unique symbol;
+/**
+ * Cria um schema Zod para upload de arquivo
+ *
+ * @example
+ * ```typescript
+ * app.post("/upload", {
+ *   middleware: {
+ *     schema: (zod) => ({
+ *       formData: zod.object({
+ *         file: zFile(),
+ *         avatar: zFile("Foto de perfil"),
+ *         documents: zFiles("Documentos PDF"),
+ *       }),
+ *     }),
+ *   },
+ *   route: async ({ formData }) => {
+ *     const file = formData.file as File;
+ *     // ...
+ *   },
+ * });
+ * ```
+ */
+declare function zFile(description?: string): z.ZodAny;
+/**
+ * Cria um schema Zod para upload de múltiplos arquivos
+ */
+declare function zFiles(description?: string): z.ZodArray<z.ZodAny, "many">;
+/**
+ * Verifica se um schema Zod é um schema de arquivo
+ */
+declare function isFileSchema(schema: z.ZodTypeAny): boolean;
+/**
+ * Verifica se um schema Zod é um schema de múltiplos arquivos
+ */
+declare function isMultipleFileSchema(schema: z.ZodTypeAny): boolean;
+
+/**
+ * Cria middleware que resolve o banco de dados e coloca no contexto.
+ *
+ * Este middleware usa o TenantManager.getContextualClient() para:
+ * 1. Resolver a URL do banco (single ou dynamic)
+ * 2. Aplicar $extends com filtro de tenantId (se aplicável)
+ * 3. Colocar o cliente no contexto via c.set('db', client)
+ *
+ * @param tenantManager - Instância do TenantManager
+ * @returns Middleware do Hono
+ *
+ * @example
+ * ```typescript
+ * // No framework.ts
+ * const dbMiddleware = createDatabaseMiddleware(tenantManager);
+ * honoApp.use('*', dbMiddleware);
+ *
+ * // Nas rotas
+ * app.get('/users', {
+ *   route: async ({ db }) => {
+ *     // db já vem com filtro de tenant aplicado
+ *     const users = await db.user.findMany();
+ *     return { data: users };
+ *   },
+ * });
+ * ```
+ */
+declare function createDatabaseMiddleware(tenantManager: TenantManager): (c: Context, next: Next) => Promise<void>;
+/**
+ * Tipo do contexto com db disponível.
+ * Útil para tipar middlewares customizados.
+ */
+interface DatabaseContext {
+    db: any;
+}
+/**
+ * Helper para obter db do contexto de forma tipada.
+ *
+ * @example
+ * ```typescript
+ * const db = getDbFromContext<PrismaClient>(c);
+ * const users = await db.user.findMany();
+ * ```
+ */
+declare function getDbFromContext<TPrisma = any>(c: Context): TPrisma;
+
+export { type DatabaseContext, FILE_SCHEMA_SYMBOL, RedisConfig, SchemaDefinition, type StartZetiOptions, SwaggerRegistry, TenantManager, WorkerConfig, WorkerInstance, WorkerManager, type ZetiApp, ZetiConfigInternal, ZetiMethodOptions, type ZetiMiddlewareHandler, ZetiPrismaConnectionConfig, autoInitializeZetiApp, badRequestError, conflictError, createAppProxy, createDatabaseMiddleware, createZetiApp, env, forbiddenError, getDbFromContext, getPrismaClient, getPrismaConnectionConfig, getRedis, getRedisConfiguration, getWorkerManager, getZetiApp, getZetiAppTyped, goneError, hasRedis, honoRoutesZeti, initializeZetiApp, internalServerError, isFileSchema, isMultipleFileSchema, loadEnv, notFoundError, shutdownZeti, startZeti, stopAllWorkers, unauthorizedError, unprocessableEntityError, zFile, zFiles };

package/dist/prisma/index.d.ts

@@ -0,0 +1,59 @@
+import { a as ZetiConfigInternal } from '../config-VWgz0Iq_.js';
+import 'hono';
+import 'ioredis';
+import 'hono/http-exception';
+
+interface PrismaConfigOptions {
+    /** Caminho do schema. Default: "prisma/schema.prisma" */
+    schema?: string;
+    /** Caminho das migrations. Default: "prisma/migrations" */
+    migrationsPath?: string;
+}
+interface PrismaDefineConfig {
+    schema: string;
+    migrations: {
+        path: string;
+    };
+    datasource: {
+        url: string;
+    };
+}
+/**
+ * Gera a configuração do Prisma.
+ *
+ * Aceita opcionalmente um ZetiConfig, mas NÃO É NECESSÁRIO passá-lo.
+ * A função busca automaticamente a URL do banco no .env.
+ *
+ * @example Uso simples (recomendado para evitar importar zeti.config.ts)
+ * ```typescript
+ * // prisma.config.ts
+ * import { definePrismaConfig } from "zeti-framework";
+ *
+ * export default definePrismaConfig();
+ * ```
+ *
+ * @example Uso com config (opcional)
+ * ```typescript
+ * // prisma.config.ts
+ * import { zetiConfig } from "./zeti.config";
+ * import { definePrismaConfig } from "zeti-framework";
+ *
+ * export default definePrismaConfig(zetiConfig);
+ * ```
+ */
+declare function definePrismaConfig(zetiConfigOrOptions?: ZetiConfigInternal | PrismaConfigOptions, options?: PrismaConfigOptions): PrismaDefineConfig;
+/**
+ * Retorna todas as URLs de banco de dados configuradas (para multi-tenant migrations).
+ *
+ * @example
+ * ```typescript
+ * const urls = getAllDatabaseUrls(zetiConfig);
+ * for (const [name, url] of Object.entries(urls)) {
+ *   console.log(`Migrating ${name}...`);
+ *   // executar migration para cada tenant
+ * }
+ * ```
+ */
+declare function getAllDatabaseUrls(zetiConfig: ZetiConfigInternal): Record<string, string>;
+
+export { type PrismaConfigOptions, definePrismaConfig, getAllDatabaseUrls };

package/dist/scripts/index.d.ts

@@ -0,0 +1,34 @@
+import { a as ZetiConfigInternal } from '../config-VWgz0Iq_.js';
+import 'hono';
+import 'ioredis';
+import 'hono/http-exception';
+
+interface GenerateRegistryOptions {
+    controllersPath: string;
+    indexPath: string;
+    startMarker?: string;
+    endMarker?: string;
+    /** Se true, escreve apenas os imports no arquivo (para .zeti/registry.ts) */
+    outputMode?: 'inject' | 'standalone';
+}
+declare function generateRegistry(options: GenerateRegistryOptions): Promise<void>;
+
+interface GenerateSwaggerTypesOptions {
+    controllersPath: string;
+    outputPath: string;
+}
+declare function generateSwaggerTypes(options: GenerateSwaggerTypesOptions): Promise<void>;
+
+interface RunPrebuildOptions {
+    projectRoot?: string;
+    zetiConfig?: ZetiConfigInternal;
+    controllersPath?: string;
+    registryPath?: string;
+    swaggerOutputPath?: string;
+    prismaImport?: string;
+    /** Forçar regeneração mesmo se não houver mudanças */
+    force?: boolean;
+}
+declare function runPrebuild(options?: RunPrebuildOptions): Promise<void>;
+
+export { type GenerateRegistryOptions, type GenerateSwaggerTypesOptions, type RunPrebuildOptions, generateRegistry, generateSwaggerTypes, runPrebuild };

package/dist/swagger/index.d.ts

@@ -0,0 +1,10 @@
+export { S as SwaggerGeneratorOptions, a as SwaggerRegistry, g as generateSwagger } from '../generator-CK-ZmWQj.js';
+import { ZodTypeAny } from 'zod';
+import 'hono';
+import '../config-VWgz0Iq_.js';
+import 'ioredis';
+import 'hono/http-exception';
+
+declare function zodToJsonSchema(schema: ZodTypeAny): any;
+
+export { zodToJsonSchema };

package/dist/tenants/index.d.ts

@@ -0,0 +1,146 @@
+import { Context } from 'hono';
+import { h as ZetiDatabaseConfig, m as ZetiPrismaConfig, b as ZetiPrismaConnectionConfig, T as TenantSelection, C as ConnectionStrategy } from '../config-VWgz0Iq_.js';
+import 'ioredis';
+import 'hono/http-exception';
+
+interface TenantMetrics {
+    totalTenants: number;
+    activeConnections: number;
+    cachedConnections: number;
+    connectionPoolSize: number;
+    cacheHits: number;
+    cacheMisses: number;
+    errors: number;
+    lastCleanup?: Date;
+    uptime: number;
+}
+declare class MetricsCollector {
+    private metrics;
+    private startTime;
+    private cacheHitCount;
+    private cacheMissCount;
+    private errorCount;
+    incrementCacheHit(): void;
+    incrementCacheMiss(): void;
+    incrementError(): void;
+    updateMetrics(data: {
+        totalTenants?: number;
+        activeConnections?: number;
+        cachedConnections?: number;
+        connectionPoolSize?: number;
+        lastCleanup?: Date;
+    }): void;
+    getMetrics(): TenantMetrics;
+    reset(): void;
+}
+
+/**
+ * TenantManager com suporte a Modos de Operação (single/dynamic)
+ *
+ * Características:
+ * - Cache por URL (hash MD5) para reutilizar instâncias base
+ * - Detecção automática de models com tenantId via DMMF
+ * - $extends leve aplicado por request (sem cache)
+ * - Suporte a workers (sem Context do Hono)
+ */
+declare class TenantManager {
+    private readonly MAX_RECOMMENDED_DATABASES;
+    private databaseConnections;
+    private specialDatabases;
+    private baseClients;
+    private clients;
+    private modelFieldsCache;
+    private config;
+    private databaseConfig;
+    private prismaConnectionConfig?;
+    private metrics;
+    private cleanupInterval?;
+    constructor(databaseConfig: ZetiDatabaseConfig, prismaConfig: ZetiPrismaConfig, specialDatabases?: Record<string, string>, prismaConnectionConfig?: ZetiPrismaConnectionConfig);
+    /**
+     * Obtém cliente contextual baseado na estratégia de conexão.
+     *
+     * Suporta duas formas de definir escopo de segurança:
+     * 1. Via `tenantSelector` no config (modo dynamic)
+     * 2. Via `context.set('securityScope', scope)` no middleware
+     *
+     * O securityScope do middleware tem PRIORIDADE sobre o tenantSelector.
+     *
+     * @param context - Context do Hono (request)
+     * @returns PrismaClient com ou sem $extends de segurança
+     */
+    getContextualClient(context: Context): Promise<any>;
+    /**
+     * Obtém cliente para workers (sem Context do Hono).
+     *
+     * @param selection - TenantSelection manual
+     * @returns PrismaClient com ou sem $extends de tenant
+     */
+    getClientForWorker(selection?: TenantSelection): any;
+    /**
+     * Obtém cliente base (sem extensões de segurança).
+     * Usado pelo middleware global para disponibilizar db aos middlewares do usuário.
+     *
+     * @returns PrismaClient base
+     */
+    getBaseClient(): Promise<any>;
+    /**
+     * Obtém ou cria cliente base cacheado por URL.
+     *
+     * @param url - Connection string do banco
+     * @returns PrismaClient base (sem extensions)
+     */
+    getOrCreateBaseClient(url: string): any;
+    /**
+     * Aplica $extends com VALIDAÇÃO de campos de segurança.
+     *
+     * Esta abordagem:
+     * - VALIDA que o campo passado é igual ao do escopo de segurança
+     * - Adiciona o campo ao WHERE em queries de leitura (filtro de segurança)
+     * - FALHA se o campo não for passado ou for diferente em create/update
+     *
+     * Isso garante que:
+     * 1. O desenvolvedor sempre passa explicitamente o campo
+     * 2. Não é possível acessar/modificar dados de outro contexto
+     *
+     * @param baseClient - Cliente Prisma base
+     * @param scopeFields - Campos do escopo de segurança (ex: { tenantId: 'abc', productId: 'xyz' })
+     * @param urlHash - Hash da URL do banco para cache de campos
+     */
+    private applySecurityExtension;
+    /**
+     * Detecta todos os campos de cada model via DMMF.
+     * Resultado é cacheado por URL hash.
+     *
+     * Isso permite validação genérica de qualquer campo retornado pelo tenantSelector.
+     */
+    private detectModelFields;
+    /**
+     * Gera hash MD5 da URL para usar como chave de cache.
+     * Isso evita expor credenciais em logs.
+     */
+    private hashUrl;
+    /**
+     * Modo legado - usa lógica antiga baseada em databaseId.
+     */
+    private getLegacyClient;
+    private startCleanupInterval;
+    private cleanupExpiredConnections;
+    private cleanupCache;
+    getMetrics(): TenantMetrics;
+    getTenantDatabase(databaseId: string): Promise<any>;
+    getSpecialDatabase(key: string): any;
+    private getOrCreateClient;
+    isValidDatabase(databaseId: string): boolean;
+    getAllDatabases(): string[];
+    /**
+     * Retorna a estratégia de conexão configurada.
+     */
+    getConnectionStrategy(): ConnectionStrategy;
+    /**
+     * Verifica se está usando o novo modo de operação.
+     */
+    isUsingConnectionConfig(): boolean;
+    shutdown(): Promise<void>;
+}
+
+export { MetricsCollector, TenantManager, type TenantMetrics };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeti-framework-backend",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Framework Hono com suporte a multi-tenancy, Prisma e Swagger automático",
   "type": "module",
   "main": "./dist/index.js",