Kashif Wahaj

import { TenantResolver, PoolManager, RBAC } from '@infra/security';

// Middleware enforcing zero-trust data segregation per tenant
export async function tenantIsolationMiddleware(req: Request, next: NextFn) {
  const tenant = await TenantResolver.fromRequest(req);
  if (!tenant || !tenant.isActive) throw new UnauthorizedError('Invalid tenant');

  // Enforce role-based attribute permissions against tenant boundary
  const hasAccess = await RBAC.verify(req.user, 'read:reports', tenant.id);
  if (!hasAccess) throw new ForbiddenError('Cross-tenant violation blocked');

  // Dynamically attach isolated database connection pool
  return PoolManager.runInTenantContext(tenant.schema, async () => {
    return next();
  });
}

import { BedrockRuntime, VectorStore, SemanticCache } from '@infra/ai';

// LLMOps pipeline with semantic caching, hybrid retrieval & guardrails
export async function executeAgentWorkflow(userQuery: string) {
  const cached = await SemanticCache.getSimilarity(userQuery, { threshold: . });
  if (cached) return { stream: cached.stream, cached: true };

  const documents = await VectorStore.hybridSearch(userQuery, { topK: , rerank: true });
  const agentPlan = await BedrockRuntime.invokeModel({
    modelId: 'anthropic.claude-3-5-sonnet',
    prompt: buildGroundedPrompt(userQuery, documents),
    guardrails: { piiFilter: true, hallucinationThreshold: . },
  });

  await SemanticCache.set(userQuery, agentPlan);
  return agentPlan;
} 

import { trace, metrics, SpanStatusCode } from '@opentelemetry/api';

// Distributed span wrapper propagating trace context across microservices
export async function recordTraceSpan<T>(name: string, fn: () => Promise<T>): Promise<T> {
  const tracer = trace.getTracer('distributed-core');
  const latencyTimer = metrics.getHistogram('operation_duration_ms');

  return tracer.startActiveSpan(name, async (span) => {
    const start = performance.now();
    try {
      const result = await fn();
      span.setStatus({ code: SpanStatusCode.OK });
      return result;
    } catch (err: any) {
      span.recordException(err);
      span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
      throw err;
    } finally {
      latencyTimer.record(performance.now() - start, { operation: name });
      span.end();
    }
  });
}