iec-cli 0.6.6

package/dist/templates/mga/{{name}}-api/src/models/invite.ts

@@ -0,0 +1,39 @@
+import mongoose, { type Document, Schema } from 'mongoose'
+
+export type InviteStatus = 'pending' | 'accepted' | 'expired'
+
+export interface IInvite extends Document {
+  email: string
+  firstName: string
+  lastName: string
+  invitedBy: string
+  token: string
+  status: InviteStatus
+  expiresAt: Date
+  acceptedAt: Date | null
+  createdAt: Date
+}
+
+const inviteSchema = new Schema<IInvite>(
+  {
+    email: { type: String, required: true, lowercase: true, trim: true },
+    firstName: { type: String, required: true, trim: true },
+    lastName: { type: String, required: true, trim: true },
+    invitedBy: { type: String, required: true },
+    token: { type: String, required: true, unique: true },
+    status: {
+      type: String,
+      enum: ['pending', 'accepted', 'expired'],
+      default: 'pending',
+    },
+    expiresAt: { type: Date, required: true },
+    acceptedAt: { type: Date, default: null },
+  },
+  { timestamps: true },
+)
+
+inviteSchema.index({ token: 1 }, { unique: true })
+inviteSchema.index({ email: 1 })
+inviteSchema.index({ status: 1 })
+
+export const Invite = mongoose.model<IInvite>('Invite', inviteSchema)

package/dist/templates/mga/{{name}}-api/src/models/policy.ts

@@ -0,0 +1,59 @@
+import mongoose, { type Document, Schema } from 'mongoose'
+
+export type PolicyStatus = 'active' | 'cancelled' | 'expired' | 'lapsed'
+
+export interface IPolicyCoverageLimits {
+  dataBreachLimit: number
+  ransomwareLimit: number
+  liabilityLimit: number
+}
+
+export interface IPolicy extends Document {
+  quoteId: string
+  applicationId: string
+  productId: string
+  agentId: string
+  insuredName: string
+  insuredEmail: string
+  policyNumber: string
+  premiumAmount: number
+  coverageLimits: IPolicyCoverageLimits
+  effectiveDate: Date
+  expirationDate: Date
+  status: PolicyStatus
+  createdAt: Date
+  updatedAt: Date
+}
+
+const policySchema = new Schema<IPolicy>(
+  {
+    quoteId: { type: String, required: true },
+    applicationId: { type: String, required: true },
+    productId: { type: String, required: true },
+    agentId: { type: String, required: true },
+    insuredName: { type: String, required: true, trim: true },
+    insuredEmail: { type: String, required: true, lowercase: true, trim: true },
+    policyNumber: { type: String, required: true, unique: true },
+    premiumAmount: { type: Number, required: true },
+    coverageLimits: {
+      dataBreachLimit: { type: Number, required: true },
+      ransomwareLimit: { type: Number, required: true },
+      liabilityLimit: { type: Number, required: true },
+    },
+    effectiveDate: { type: Date, required: true },
+    expirationDate: { type: Date, required: true },
+    status: {
+      type: String,
+      enum: ['active', 'cancelled', 'expired', 'lapsed'],
+      default: 'active',
+    },
+  },
+  { timestamps: true },
+)
+
+policySchema.index({ policyNumber: 1 }, { unique: true })
+policySchema.index({ agentId: 1, status: 1 })
+policySchema.index({ status: 1 })
+policySchema.index({ insuredEmail: 1 })
+
+export const Policy = mongoose.model<IPolicy>('Policy', policySchema)

package/dist/templates/mga/{{name}}-api/src/models/product.ts

@@ -0,0 +1,51 @@
+import mongoose, { type Document, Schema } from 'mongoose'
+
+export interface ICoverageLimits {
+  dataBreachLimit: number
+  ransomwareLimit: number
+  liabilityLimit: number
+}
+
+export interface IRiskFactors {
+  industryMultipliers: Record<string, number>
+}
+
+export interface IProduct extends Document {
+  name: string
+  description: string
+  basePremiumPerEmployee: number
+  minEmployees: number
+  maxEmployees: number
+  coverageLimits: ICoverageLimits
+  riskFactors: IRiskFactors
+  active: boolean
+  createdBy: string
+  createdAt: Date
+  updatedAt: Date
+}
+
+const productSchema = new Schema<IProduct>(
+  {
+    name: { type: String, required: true, trim: true },
+    description: { type: String, required: true },
+    basePremiumPerEmployee: { type: Number, required: true },
+    minEmployees: { type: Number, required: true, default: 1 },
+    maxEmployees: { type: Number, required: true, default: 10000 },
+    coverageLimits: {
+      dataBreachLimit: { type: Number, required: true },
+      ransomwareLimit: { type: Number, required: true },
+      liabilityLimit: { type: Number, required: true },
+    },
+    riskFactors: {
+      industryMultipliers: { type: Map, of: Number, default: {} },
+    },
+    active: { type: Boolean, default: true },
+    createdBy: { type: String, required: true },
+  },
+  { timestamps: true },
+)
+
+productSchema.index({ active: 1 })
+productSchema.index({ name: 1 }, { unique: true })
+
+export const Product = mongoose.model<IProduct>('Product', productSchema)

package/dist/templates/mga/{{name}}-api/src/models/quote.ts

@@ -0,0 +1,68 @@
+import mongoose, { type Document, Schema } from 'mongoose'
+
+export type QuoteStatus = 'pending' | 'accepted' | 'declined' | 'expired'
+
+export interface ICalculationDetails {
+  basePremiumPerEmployee: number
+  employeeCount: number
+  limitFactor: number
+  riskFactor: number
+  breakdown: string
+}
+
+export interface IQuoteCoverageLimits {
+  dataBreachLimit: number
+  ransomwareLimit: number
+  liabilityLimit: number
+}
+
+export interface IQuote extends Document {
+  applicationId: string
+  productId: string
+  agentId: string
+  premiumAmount: number
+  coverageLimits: IQuoteCoverageLimits
+  deductible: number
+  termMonths: number
+  status: QuoteStatus
+  validUntil: Date
+  calculationDetails: ICalculationDetails
+  createdAt: Date
+  updatedAt: Date
+}
+
+const quoteSchema = new Schema<IQuote>(
+  {
+    applicationId: { type: String, required: true },
+    productId: { type: String, required: true },
+    agentId: { type: String, required: true },
+    premiumAmount: { type: Number, required: true },
+    coverageLimits: {
+      dataBreachLimit: { type: Number, required: true },
+      ransomwareLimit: { type: Number, required: true },
+      liabilityLimit: { type: Number, required: true },
+    },
+    deductible: { type: Number, required: true },
+    termMonths: { type: Number, default: 12 },
+    status: {
+      type: String,
+      enum: ['pending', 'accepted', 'declined', 'expired'],
+      default: 'pending',
+    },
+    validUntil: { type: Date, required: true },
+    calculationDetails: {
+      basePremiumPerEmployee: { type: Number, required: true },
+      employeeCount: { type: Number, required: true },
+      limitFactor: { type: Number, required: true },
+      riskFactor: { type: Number, required: true },
+      breakdown: { type: String, required: true },
+    },
+  },
+  { timestamps: true },
+)
+
+quoteSchema.index({ applicationId: 1 })
+quoteSchema.index({ agentId: 1, status: 1 })
+quoteSchema.index({ status: 1, validUntil: 1 })
+
+export const Quote = mongoose.model<IQuote>('Quote', quoteSchema)

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

@@ -0,0 +1,98 @@
+import { Router, type Request, type Response } from 'express'
+import { z } from 'zod'
+import { authMiddleware, requireRole } from '../middleware/auth.js'
+import { Agent } from '../models/agent.js'
+
+const router = Router()
+
+const UpdateAgentStatusSchema = z.object({
+  status: z.enum(['active', 'suspended', 'inactive']),
+})
+
+// List all agents (admin only)
+router.get('/', authMiddleware, requireRole('mga_admin'), async (_req: Request, res: Response) => {
+  try {
+    const agents = await Agent.find().sort({ lastName: 1, firstName: 1 }).lean()
+    res.json({
+      success: true,
+      data: agents,
+      meta: { total: agents.length },
+    })
+  } catch (err) {
+    process.stderr.write(`Failed to list agents: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to list agents' },
+    })
+  }
+})
+
+// Get agent profile (agent sees own, admin sees any)
+router.get('/:id', authMiddleware, requireRole('mga_admin', 'agent'), async (req: Request, res: Response) => {
+  try {
+    const agent = await Agent.findById(req.params.id).lean()
+    if (!agent) {
+      res.status(404).json({
+        success: false,
+        error: { code: 'NOT_FOUND', message: 'Agent not found' },
+      })
+      return
+    }
+
+    // Agents can only view their own profile
+    const isAdmin = req.user!.roles.includes('mga_admin')
+    if (!isAdmin && agent.userId !== req.user!.id) {
+      res.status(403).json({
+        success: false,
+        error: { code: 'FORBIDDEN', message: 'Insufficient permissions' },
+      })
+      return
+    }
+
+    res.json({ success: true, data: agent })
+  } catch (err) {
+    process.stderr.write(`Failed to get agent: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to get agent' },
+    })
+  }
+})
+
+// Update agent status (admin only)
+router.put('/:id/status', authMiddleware, requireRole('mga_admin'), async (req: Request, res: Response) => {
+  const result = UpdateAgentStatusSchema.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 agent = await Agent.findByIdAndUpdate(
+      req.params.id,
+      { $set: { status: result.data.status } },
+      { new: true, runValidators: true },
+    ).lean()
+
+    if (!agent) {
+      res.status(404).json({
+        success: false,
+        error: { code: 'NOT_FOUND', message: 'Agent not found' },
+      })
+      return
+    }
+
+    res.json({ success: true, data: agent })
+  } catch (err) {
+    process.stderr.write(`Failed to update agent status: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to update agent status' },
+    })
+  }
+})
+
+export { router as agentsRouter }

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

@@ -0,0 +1,170 @@
+import { Router, type Request, type Response } from 'express'
+import { z } from 'zod'
+import { authMiddleware, requireRole } from '../middleware/auth.js'
+import { Application } from '../models/application.js'
+
+const router = Router()
+
+const US_STATE_CODES = [
+  'AL', 'AK', 'AZ', 'AR', 'CA', 'CO', 'CT', 'DE', 'FL', 'GA',
+  'HI', 'ID', 'IL', 'IN', 'IA', 'KS', 'KY', 'LA', 'ME', 'MD',
+  'MA', 'MI', 'MN', 'MS', 'MO', 'MT', 'NE', 'NV', 'NH', 'NJ',
+  'NM', 'NY', 'NC', 'ND', 'OH', 'OK', 'OR', 'PA', 'RI', 'SC',
+  'SD', 'TN', 'TX', 'UT', 'VT', 'VA', 'WA', 'WV', 'WI', 'WY', 'DC',
+] as const
+
+const CreateApplicationSchema = z.object({
+  applicantName: z.string().min(1).max(200),
+  applicantEmail: z.string().email(),
+  companyName: z.string().min(1).max(300),
+  industry: z.string().min(1).max(100),
+  employeeCount: z.number().int().positive(),
+  annualRevenue: z.number().int().nonnegative(),
+  currentCoverage: z.boolean().default(false),
+  previousClaims: z.number().int().nonnegative().default(0),
+  requestedCoverageLimit: z.number().int().positive(),
+  productId: z.string().min(1),
+  notes: z.string().max(5000).default(''),
+  state: z.enum(US_STATE_CODES),
+})
+
+const UpdateApplicationSchema = CreateApplicationSchema.partial().extend({
+  status: z.enum(['draft', 'submitted', 'quoted', 'bound', 'declined', 'expired']).optional(),
+})
+
+// List applications (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.applicantEmail = user.email
+    }
+
+    const applications = await Application.find(filter).sort({ createdAt: -1 }).lean()
+    res.json({
+      success: true,
+      data: applications,
+      meta: { total: applications.length },
+    })
+  } catch (err) {
+    process.stderr.write(`Failed to list applications: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to list applications' },
+    })
+  }
+})
+
+// Get single application
+router.get('/:id', authMiddleware, requireRole('mga_admin', 'agent', 'insured'), async (req: Request, res: Response) => {
+  try {
+    const application = await Application.findById(req.params.id).lean()
+    if (!application) {
+      res.status(404).json({
+        success: false,
+        error: { code: 'NOT_FOUND', message: 'Application not found' },
+      })
+      return
+    }
+
+    const user = req.user!
+    const isAdmin = user.roles.includes('mga_admin')
+    const isOwnAgent = user.roles.includes('agent') && application.agentId === user.id
+    const isOwnInsured = user.roles.includes('insured') && application.applicantEmail === user.email
+
+    if (!isAdmin && !isOwnAgent && !isOwnInsured) {
+      res.status(403).json({
+        success: false,
+        error: { code: 'FORBIDDEN', message: 'Insufficient permissions' },
+      })
+      return
+    }
+
+    res.json({ success: true, data: application })
+  } catch (err) {
+    process.stderr.write(`Failed to get application: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to get application' },
+    })
+  }
+})
+
+// Create application
+router.post('/', authMiddleware, requireRole('agent', 'insured'), async (req: Request, res: Response) => {
+  const result = CreateApplicationSchema.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.create({
+      ...result.data,
+      agentId: req.user!.id,
+    })
+    res.status(201).json({ success: true, data: application.toObject() })
+  } catch (err) {
+    process.stderr.write(`Failed to create application: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to create application' },
+    })
+  }
+})
+
+// Update application
+router.put('/:id', authMiddleware, requireRole('mga_admin', 'agent'), async (req: Request, res: Response) => {
+  const result = UpdateApplicationSchema.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 existing = await Application.findById(req.params.id).lean()
+    if (!existing) {
+      res.status(404).json({
+        success: false,
+        error: { code: 'NOT_FOUND', message: 'Application not found' },
+      })
+      return
+    }
+
+    const isAdmin = req.user!.roles.includes('mga_admin')
+    if (!isAdmin && existing.agentId !== req.user!.id) {
+      res.status(403).json({
+        success: false,
+        error: { code: 'FORBIDDEN', message: 'Insufficient permissions' },
+      })
+      return
+    }
+
+    const application = await Application.findByIdAndUpdate(
+      req.params.id,
+      { $set: result.data },
+      { new: true, runValidators: true },
+    ).lean()
+
+    res.json({ success: true, data: application })
+  } catch (err) {
+    process.stderr.write(`Failed to update application: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to update application' },
+    })
+  }
+})
+
+export { router as applicationsRouter }

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

@@ -0,0 +1,146 @@
+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 { Invite } from '../models/invite.js'
+import { Agent } from '../models/agent.js'
+
+const router = Router()
+
+const INVITE_EXPIRY_DAYS = 7
+
+const CreateInviteSchema = z.object({
+  email: z.string().email(),
+  firstName: z.string().min(1).max(100),
+  lastName: z.string().min(1).max(100),
+})
+
+// List all invites (admin only)
+router.get('/', authMiddleware, requireRole('mga_admin'), async (_req: Request, res: Response) => {
+  try {
+    const invites = await Invite.find().sort({ createdAt: -1 }).lean()
+    res.json({
+      success: true,
+      data: invites,
+      meta: { total: invites.length },
+    })
+  } catch (err) {
+    process.stderr.write(`Failed to list invites: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to list invites' },
+    })
+  }
+})
+
+// Create invite (admin only)
+router.post('/', authMiddleware, requireRole('mga_admin'), async (req: Request, res: Response) => {
+  const result = CreateInviteSchema.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 existingInvite = await Invite.findOne({
+      email: result.data.email,
+      status: 'pending',
+    }).lean()
+
+    if (existingInvite) {
+      res.status(409).json({
+        success: false,
+        error: { code: 'CONFLICT', message: 'A pending invite already exists for this email' },
+      })
+      return
+    }
+
+    const expiresAt = new Date()
+    expiresAt.setDate(expiresAt.getDate() + INVITE_EXPIRY_DAYS)
+
+    const invite = await Invite.create({
+      ...result.data,
+      invitedBy: req.user!.id,
+      token: crypto.randomBytes(32).toString('hex'),
+      expiresAt,
+    })
+
+    res.status(201).json({ success: true, data: invite.toObject() })
+  } catch (err) {
+    process.stderr.write(`Failed to create invite: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to create invite' },
+    })
+  }
+})
+
+// Accept invite (public with token)
+router.post('/accept', async (req: Request, res: Response) => {
+  const tokenSchema = z.object({
+    token: z.string().min(1),
+    userId: z.string().min(1),
+    licenseNumber: z.string().min(1),
+    licenseState: z.string().length(2),
+  })
+
+  const result = tokenSchema.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 invite = await Invite.findOne({
+      token: result.data.token,
+      status: 'pending',
+    })
+
+    if (!invite) {
+      res.status(404).json({
+        success: false,
+        error: { code: 'NOT_FOUND', message: 'Invite not found or already used' },
+      })
+      return
+    }
+
+    if (invite.expiresAt < new Date()) {
+      await Invite.findByIdAndUpdate(invite._id, { $set: { status: 'expired' } })
+      res.status(410).json({
+        success: false,
+        error: { code: 'EXPIRED', message: 'This invite has expired' },
+      })
+      return
+    }
+
+    const agent = await Agent.create({
+      userId: result.data.userId,
+      email: invite.email,
+      firstName: invite.firstName,
+      lastName: invite.lastName,
+      licenseNumber: result.data.licenseNumber,
+      licenseState: result.data.licenseState,
+      invitedBy: invite.invitedBy,
+    })
+
+    await Invite.findByIdAndUpdate(invite._id, {
+      $set: { status: 'accepted', acceptedAt: new Date() },
+    })
+
+    res.status(201).json({ success: true, data: agent.toObject() })
+  } catch (err) {
+    process.stderr.write(`Failed to accept invite: ${err instanceof Error ? err.message : String(err)}\n`)
+    res.status(500).json({
+      success: false,
+      error: { code: 'INTERNAL_ERROR', message: 'Failed to accept invite' },
+    })
+  }
+})
+
+export { router as invitesRouter }