iec-cli 0.6.6

package/dist/templates/mga/{{name}}-api/src/routes/policies.ts

@@ -0,0 +1,70 @@
+import { Router, type Request, type Response } from 'express'
+import { authMiddleware, requireRole } from '../middleware/auth.js'
+import { Policy } from '../models/policy.js'
+
+const router = Router()
+
+// List policies (role-filtered)
+router.get('/', authMiddleware, requireRole('mga_admin', 'agent', 'insured'), async (req: Request, res: Response) => {
+  try {
+    const user = req.user!
+    const isAdmin = user.roles.includes('mga_admin')
+
+    const filter: Record<string, unknown> = {}
+    if (!isAdmin && user.roles.includes('agent')) {
+      filter.agentId = user.id
+    } else if (!isAdmin && user.roles.includes('insured')) {
+      filter.insuredEmail = user.email
+    }
+
+    const policies = await Policy.find(filter).sort({ createdAt: -1 }).lean()
+    res.json({
+      success: true,
+      data: policies,
+      meta: { total: policies.length },
+    })
+  } catch (err) {
+    process.stderr.write(`Failed to list policies: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to list policies' },
+    })
+  }
+})
+
+// Get single policy
+router.get('/:id', authMiddleware, requireRole('mga_admin', 'agent', 'insured'), async (req: Request, res: Response) => {
+  try {
+    const policy = await Policy.findById(req.params.id).lean()
+    if (!policy) {
+      res.status(404).json({
+        success: false,
+        error: { code: 'NOT_FOUND', message: 'Policy not found' },
+      })
+      return
+    }
+
+    const user = req.user!
+    const isAdmin = user.roles.includes('mga_admin')
+    const isOwnAgent = user.roles.includes('agent') && policy.agentId === user.id
+    const isOwnInsured = user.roles.includes('insured') && policy.insuredEmail === user.email
+
+    if (!isAdmin && !isOwnAgent && !isOwnInsured) {
+      res.status(403).json({
+        success: false,
+        error: { code: 'FORBIDDEN', message: 'Insufficient permissions' },
+      })
+      return
+    }
+
+    res.json({ success: true, data: policy })
+  } catch (err) {
+    process.stderr.write(`Failed to get policy: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to get policy' },
+    })
+  }
+})
+
+export { router as policiesRouter }

package/dist/templates/mga/{{name}}-api/src/routes/products.ts

@@ -0,0 +1,154 @@
+import { Router, type Request, type Response } from 'express'
+import { z } from 'zod'
+import { authMiddleware, requireRole } from '../middleware/auth.js'
+import { Product } from '../models/product.js'
+
+const router = Router()
+
+const CreateProductSchema = z.object({
+  name: z.string().min(1).max(200),
+  description: z.string().min(1).max(2000),
+  basePremiumPerEmployee: z.number().int().positive(),
+  minEmployees: z.number().int().positive().default(1),
+  maxEmployees: z.number().int().positive().default(10000),
+  coverageLimits: z.object({
+    dataBreachLimit: z.number().int().positive(),
+    ransomwareLimit: z.number().int().positive(),
+    liabilityLimit: z.number().int().positive(),
+  }),
+  riskFactors: z.object({
+    industryMultipliers: z.record(z.string(), z.number().positive()),
+  }),
+})
+
+const UpdateProductSchema = CreateProductSchema.partial().extend({
+  active: z.boolean().optional(),
+})
+
+// List all active products
+router.get('/', authMiddleware, async (_req: Request, res: Response) => {
+  try {
+    const products = await Product.find({ active: true }).sort({ name: 1 }).lean()
+    res.json({
+      success: true,
+      data: products,
+      meta: { total: products.length },
+    })
+  } catch (err) {
+    process.stderr.write(`Failed to list products: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to list products' },
+    })
+  }
+})
+
+// Get single product
+router.get('/:id', authMiddleware, async (req: Request, res: Response) => {
+  try {
+    const product = await Product.findById(req.params.id).lean()
+    if (!product) {
+      res.status(404).json({
+        success: false,
+        error: { code: 'NOT_FOUND', message: 'Product not found' },
+      })
+      return
+    }
+    res.json({ success: true, data: product })
+  } catch (err) {
+    process.stderr.write(`Failed to get product: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to get product' },
+    })
+  }
+})
+
+// Create product (admin only)
+router.post('/', authMiddleware, requireRole('mga_admin'), async (req: Request, res: Response) => {
+  const result = CreateProductSchema.safeParse(req.body)
+  if (!result.success) {
+    res.status(400).json({
+      success: false,
+      error: { code: 'VALIDATION_ERROR', message: 'Invalid request body', details: result.error.flatten() },
+    })
+    return
+  }
+
+  try {
+    const product = await Product.create({
+      ...result.data,
+      createdBy: req.user!.id,
+    })
+    res.status(201).json({ success: true, data: product.toObject() })
+  } catch (err) {
+    process.stderr.write(`Failed to create product: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to create product' },
+    })
+  }
+})
+
+// Update product (admin only)
+router.put('/:id', authMiddleware, requireRole('mga_admin'), async (req: Request, res: Response) => {
+  const result = UpdateProductSchema.safeParse(req.body)
+  if (!result.success) {
+    res.status(400).json({
+      success: false,
+      error: { code: 'VALIDATION_ERROR', message: 'Invalid request body', details: result.error.flatten() },
+    })
+    return
+  }
+
+  try {
+    const product = await Product.findByIdAndUpdate(
+      req.params.id,
+      { $set: result.data },
+      { new: true, runValidators: true },
+    ).lean()
+
+    if (!product) {
+      res.status(404).json({
+        success: false,
+        error: { code: 'NOT_FOUND', message: 'Product not found' },
+      })
+      return
+    }
+    res.json({ success: true, data: product })
+  } catch (err) {
+    process.stderr.write(`Failed to update product: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to update product' },
+    })
+  }
+})
+
+// Delete product (admin only, soft delete)
+router.delete('/:id', authMiddleware, requireRole('mga_admin'), async (req: Request, res: Response) => {
+  try {
+    const product = await Product.findByIdAndUpdate(
+      req.params.id,
+      { $set: { active: false } },
+      { new: true },
+    ).lean()
+
+    if (!product) {
+      res.status(404).json({
+        success: false,
+        error: { code: 'NOT_FOUND', message: 'Product not found' },
+      })
+      return
+    }
+    res.status(204).send()
+  } catch (err) {
+    process.stderr.write(`Failed to delete product: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to delete product' },
+    })
+  }
+})
+
+export { router as productsRouter }

package/dist/templates/mga/{{name}}-api/src/routes/quotes.ts

@@ -0,0 +1,263 @@
+import { Router, type Request, type Response } from 'express'
+import { z } from 'zod'
+import crypto from 'node:crypto'
+import { authMiddleware, requireRole } from '../middleware/auth.js'
+import { Quote } from '../models/quote.js'
+import { Application } from '../models/application.js'
+import { Product, type IProduct } from '../models/product.js'
+import { Policy } from '../models/policy.js'
+import { Agent } from '../models/agent.js'
+
+const router = Router()
+
+const QUOTE_VALID_DAYS = 30
+const DEFAULT_DEDUCTIBLE_CENTS = 500_000 // $5,000 in cents
+
+const GenerateQuoteSchema = z.object({
+  applicationId: z.string().min(1),
+  deductible: z.number().int().positive().optional(),
+})
+
+function calculatePremium(
+  product: IProduct,
+  employeeCount: number,
+  requestedCoverageLimit: number,
+  industry: string,
+): { premiumAmount: number; limitFactor: number; riskFactor: number; breakdown: string } {
+  const limitFactor = requestedCoverageLimit / 1_000_000
+  const multipliers = product.riskFactors.industryMultipliers as unknown as Map<string, number>
+  const riskFactor = (multipliers instanceof Map ? multipliers.get(industry) : undefined) ?? 1.0
+  const premiumAmount = Math.round(product.basePremiumPerEmployee * employeeCount * limitFactor * riskFactor)
+  const breakdown = [
+    `base=${product.basePremiumPerEmployee}`,
+    `employees=${employeeCount}`,
+    `limitFactor=${limitFactor.toFixed(2)}`,
+    `riskFactor=${riskFactor.toFixed(2)}`,
+    `total=${premiumAmount}`,
+  ].join(' x ')
+
+  return { premiumAmount, limitFactor, riskFactor, breakdown }
+}
+
+function generatePolicyNumber(): string {
+  const prefix = 'CYB'
+  const timestamp = Date.now().toString(36).toUpperCase()
+  const random = crypto.randomBytes(3).toString('hex').toUpperCase()
+  return `${prefix}-${timestamp}-${random}`
+}
+
+// List quotes (role-filtered)
+router.get('/', authMiddleware, requireRole('mga_admin', 'agent'), async (req: Request, res: Response) => {
+  try {
+    const user = req.user!
+    const isAdmin = user.roles.includes('mga_admin')
+    const filter: Record<string, unknown> = isAdmin ? {} : { agentId: user.id }
+
+    const quotes = await Quote.find(filter).sort({ createdAt: -1 }).lean()
+    res.json({
+      success: true,
+      data: quotes,
+      meta: { total: quotes.length },
+    })
+  } catch (err) {
+    process.stderr.write(`Failed to list quotes: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to list quotes' },
+    })
+  }
+})
+
+// Get single quote
+router.get('/:id', authMiddleware, requireRole('mga_admin', 'agent'), async (req: Request, res: Response) => {
+  try {
+    const quote = await Quote.findById(req.params.id).lean()
+    if (!quote) {
+      res.status(404).json({
+        success: false,
+        error: { code: 'NOT_FOUND', message: 'Quote not found' },
+      })
+      return
+    }
+
+    const isAdmin = req.user!.roles.includes('mga_admin')
+    if (!isAdmin && quote.agentId !== req.user!.id) {
+      res.status(403).json({
+        success: false,
+        error: { code: 'FORBIDDEN', message: 'Insufficient permissions' },
+      })
+      return
+    }
+
+    res.json({ success: true, data: quote })
+  } catch (err) {
+    process.stderr.write(`Failed to get quote: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to get quote' },
+    })
+  }
+})
+
+// Generate quote from application (agent)
+router.post('/', authMiddleware, requireRole('mga_admin', 'agent'), async (req: Request, res: Response) => {
+  const result = GenerateQuoteSchema.safeParse(req.body)
+  if (!result.success) {
+    res.status(400).json({
+      success: false,
+      error: { code: 'VALIDATION_ERROR', message: 'Invalid request body', details: result.error.flatten() },
+    })
+    return
+  }
+
+  try {
+    const application = await Application.findById(result.data.applicationId)
+    if (!application) {
+      res.status(404).json({
+        success: false,
+        error: { code: 'NOT_FOUND', message: 'Application not found' },
+      })
+      return
+    }
+
+    if (application.status !== 'submitted') {
+      res.status(400).json({
+        success: false,
+        error: { code: 'INVALID_STATUS', message: 'Application must be in submitted status to generate a quote' },
+      })
+      return
+    }
+
+    const product = await Product.findById(application.productId)
+    if (!product) {
+      res.status(404).json({
+        success: false,
+        error: { code: 'NOT_FOUND', message: 'Product not found' },
+      })
+      return
+    }
+
+    const calc = calculatePremium(
+      product,
+      application.employeeCount,
+      application.requestedCoverageLimit,
+      application.industry,
+    )
+
+    const validUntil = new Date()
+    validUntil.setDate(validUntil.getDate() + QUOTE_VALID_DAYS)
+
+    const quote = await Quote.create({
+      applicationId: String(application._id),
+      productId: String(product._id),
+      agentId: req.user!.id,
+      premiumAmount: calc.premiumAmount,
+      coverageLimits: {
+        dataBreachLimit: product.coverageLimits.dataBreachLimit,
+        ransomwareLimit: product.coverageLimits.ransomwareLimit,
+        liabilityLimit: product.coverageLimits.liabilityLimit,
+      },
+      deductible: result.data.deductible ?? DEFAULT_DEDUCTIBLE_CENTS,
+      validUntil,
+      calculationDetails: {
+        basePremiumPerEmployee: product.basePremiumPerEmployee,
+        employeeCount: application.employeeCount,
+        limitFactor: calc.limitFactor,
+        riskFactor: calc.riskFactor,
+        breakdown: calc.breakdown,
+      },
+    })
+
+    await Application.findByIdAndUpdate(application._id, { $set: { status: 'quoted' } })
+
+    res.status(201).json({ success: true, data: quote.toObject() })
+  } catch (err) {
+    process.stderr.write(`Failed to generate quote: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to generate quote' },
+    })
+  }
+})
+
+// Accept quote (binds to policy)
+router.post('/:id/accept', authMiddleware, requireRole('mga_admin', 'agent'), async (req: Request, res: Response) => {
+  try {
+    const quote = await Quote.findById(req.params.id)
+    if (!quote) {
+      res.status(404).json({
+        success: false,
+        error: { code: 'NOT_FOUND', message: 'Quote not found' },
+      })
+      return
+    }
+
+    if (quote.status !== 'pending') {
+      res.status(400).json({
+        success: false,
+        error: { code: 'INVALID_STATUS', message: 'Quote must be in pending status to accept' },
+      })
+      return
+    }
+
+    if (quote.validUntil < new Date()) {
+      await Quote.findByIdAndUpdate(quote._id, { $set: { status: 'expired' } })
+      res.status(410).json({
+        success: false,
+        error: { code: 'EXPIRED', message: 'This quote has expired' },
+      })
+      return
+    }
+
+    const application = await Application.findById(quote.applicationId)
+    if (!application) {
+      res.status(404).json({
+        success: false,
+        error: { code: 'NOT_FOUND', message: 'Associated application not found' },
+      })
+      return
+    }
+
+    const effectiveDate = new Date()
+    const expirationDate = new Date()
+    expirationDate.setMonth(expirationDate.getMonth() + quote.termMonths)
+
+    const policy = await Policy.create({
+      quoteId: String(quote._id),
+      applicationId: quote.applicationId,
+      productId: quote.productId,
+      agentId: quote.agentId,
+      insuredName: application.applicantName,
+      insuredEmail: application.applicantEmail,
+      policyNumber: generatePolicyNumber(),
+      premiumAmount: quote.premiumAmount,
+      coverageLimits: { ...quote.coverageLimits },
+      effectiveDate,
+      expirationDate,
+    })
+
+    await Quote.findByIdAndUpdate(quote._id, { $set: { status: 'accepted' } })
+    await Application.findByIdAndUpdate(application._id, { $set: { status: 'bound' } })
+
+    // Update agent stats
+    await Agent.findOneAndUpdate(
+      { userId: quote.agentId },
+      {
+        $inc: {
+          policyCount: 1,
+          totalPremium: quote.premiumAmount,
+        },
+      },
+    )
+
+    res.status(201).json({ success: true, data: policy.toObject() })
+  } catch (err) {
+    process.stderr.write(`Failed to accept quote: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to accept quote' },
+    })
+  }
+})
+
+export { router as quotesRouter }

package/dist/templates/mga/{{name}}-api/src/routes/reports.ts

@@ -0,0 +1,199 @@
+import { Router, type Request, type Response } from 'express'
+import { authMiddleware, requireRole } from '../middleware/auth.js'
+import { Policy } from '../models/policy.js'
+import { Application } from '../models/application.js'
+import { Agent } from '../models/agent.js'
+
+const router = Router()
+
+// Summary report
+router.get('/summary', authMiddleware, requireRole('mga_admin', 'agent'), async (req: Request, res: Response) => {
+  try {
+    const user = req.user!
+    const isAdmin = user.roles.includes('mga_admin')
+    const policyFilter: Record<string, unknown> = isAdmin ? {} : { agentId: user.id }
+    const appFilter: Record<string, unknown> = isAdmin ? {} : { agentId: user.id }
+
+    const [policies, applicationCount] = await Promise.all([
+      Policy.find(policyFilter).lean(),
+      Application.countDocuments(appFilter),
+    ])
+
+    const totalPremium = policies.reduce((sum, p) => sum + p.premiumAmount, 0)
+    const avgPremium = policies.length > 0 ? Math.round(totalPremium / policies.length) : 0
+
+    res.json({
+      success: true,
+      data: {
+        totalPolicies: policies.length,
+        totalPremium,
+        totalApplications: applicationCount,
+        avgPremium,
+      },
+    })
+  } catch (err) {
+    process.stderr.write(`Failed to generate summary: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to generate summary report' },
+    })
+  }
+})
+
+// Premium trend (admin only)
+router.get('/premium-trend', authMiddleware, requireRole('mga_admin'), async (_req: Request, res: Response) => {
+  try {
+    const trend = await Policy.aggregate([
+      {
+        $group: {
+          _id: {
+            year: { $year: '$effectiveDate' },
+            month: { $month: '$effectiveDate' },
+          },
+          totalPremium: { $sum: '$premiumAmount' },
+          policyCount: { $sum: 1 },
+        },
+      },
+      { $sort: { '_id.year': 1, '_id.month': 1 } },
+      {
+        $project: {
+          _id: 0,
+          month: {
+            $concat: [
+              { $toString: '$_id.year' },
+              '-',
+              {
+                $cond: {
+                  if: { $lt: ['$_id.month', 10] },
+                  then: { $concat: ['0', { $toString: '$_id.month' }] },
+                  else: { $toString: '$_id.month' },
+                },
+              },
+            ],
+          },
+          totalPremium: 1,
+          policyCount: 1,
+        },
+      },
+    ])
+
+    res.json({
+      success: true,
+      data: trend,
+    })
+  } catch (err) {
+    process.stderr.write(`Failed to generate premium trend: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to generate premium trend report' },
+    })
+  }
+})
+
+// Pipeline report (admin only)
+router.get('/pipeline', authMiddleware, requireRole('mga_admin'), async (_req: Request, res: Response) => {
+  try {
+    const pipeline = await Application.aggregate([
+      {
+        $group: {
+          _id: '$status',
+          count: { $sum: 1 },
+        },
+      },
+      { $sort: { count: -1 } },
+      {
+        $project: {
+          _id: 0,
+          status: '$_id',
+          count: 1,
+        },
+      },
+    ])
+
+    res.json({
+      success: true,
+      data: pipeline,
+    })
+  } catch (err) {
+    process.stderr.write(`Failed to generate pipeline: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to generate pipeline report' },
+    })
+  }
+})
+
+// Top agents report (admin only)
+router.get('/agents', authMiddleware, requireRole('mga_admin'), async (_req: Request, res: Response) => {
+  try {
+    const agents = await Agent.find({ status: 'active' })
+      .sort({ policyCount: -1 })
+      .select('firstName lastName email policyCount totalPremium applicationCount')
+      .lean()
+
+    res.json({
+      success: true,
+      data: agents,
+      meta: { total: agents.length },
+    })
+  } catch (err) {
+    process.stderr.write(`Failed to generate agents report: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to generate agents report' },
+    })
+  }
+})
+
+// Geography report (admin only)
+router.get('/geography', authMiddleware, requireRole('mga_admin'), async (_req: Request, res: Response) => {
+  try {
+    const geography = await Application.aggregate([
+      {
+        $match: { status: 'bound' },
+      },
+      {
+        $lookup: {
+          from: 'policies',
+          let: { appId: { $toString: '$_id' } },
+          pipeline: [
+            { $match: { $expr: { $eq: ['$applicationId', '$$appId'] } } },
+          ],
+          as: 'policy',
+        },
+      },
+      { $unwind: { path: '$policy', preserveNullAndEmptyArrays: true } },
+      {
+        $group: {
+          _id: '$state',
+          totalPremium: { $sum: { $ifNull: ['$policy.premiumAmount', 0] } },
+          policyCount: {
+            $sum: { $cond: [{ $ifNull: ['$policy', false] }, 1, 0] },
+          },
+        },
+      },
+      { $sort: { totalPremium: -1 } },
+      {
+        $project: {
+          _id: 0,
+          state: '$_id',
+          totalPremium: 1,
+          policyCount: 1,
+        },
+      },
+    ])
+
+    res.json({
+      success: true,
+      data: geography,
+    })
+  } catch (err) {
+    process.stderr.write(`Failed to generate geography report: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to generate geography report' },
+    })
+  }
+})
+
+export { router as reportsRouter }

package/dist/templates/mga/{{name}}-api/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}