iec-cli 0.6.6

package/dist/templates/worker/helm/{{name}}/templates/ingress.yaml

@@ -0,0 +1,43 @@
+{{- if .Values.ingress.enabled -}}
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: {{ .Release.Name }}
+  labels:
+    app: {{ .Release.Name }}
+    app.kubernetes.io/name: {{ .Release.Name }}
+    app.kubernetes.io/instance: {{ .Release.Name }}
+  {{- with .Values.ingress.annotations }}
+  annotations:
+    {{- toYaml . | nindent 4 }}
+  {{- end }}
+spec:
+  {{- if .Values.ingress.className }}
+  ingressClassName: {{ .Values.ingress.className }}
+  {{- end }}
+  {{- if .Values.ingress.tls }}
+  tls:
+    {{- range .Values.ingress.tls }}
+    - hosts:
+        {{- range .hosts }}
+        - {{ . | quote }}
+        {{- end }}
+      secretName: {{ .secretName }}
+    {{- end }}
+  {{- end }}
+  rules:
+    {{- range .Values.ingress.hosts }}
+    - host: {{ .host | quote }}
+      http:
+        paths:
+          {{- range .paths }}
+          - path: {{ .path }}
+            pathType: {{ .pathType }}
+            backend:
+              service:
+                name: {{ $.Release.Name }}
+                port:
+                  number: {{ $.Values.service.port }}
+          {{- end }}
+    {{- end }}
+{{- end }}

package/dist/templates/worker/helm/{{name}}/values.yaml

@@ -0,0 +1,64 @@
+replicaCount: 1
+
+image:
+  repository: registry.digitalocean.com/insureco/{{name}}
+  tag: latest
+  pullPolicy: IfNotPresent
+
+imagePullSecrets:
+  - name: insureco
+
+# Workers don't expose HTTP services
+service:
+  enabled: false
+
+resources:
+  limits:
+    cpu: 500m
+    memory: 512Mi
+  requests:
+    cpu: 100m
+    memory: 128Mi
+
+env:
+  REDIS_HOST: redis
+  REDIS_PORT: "6379"
+  QUEUE_NAME: {{name}}-jobs
+  WORKER_CONCURRENCY: "5"
+
+secrets: {}
+# REDIS_PASSWORD: your-redis-password
+
+ingress:
+  enabled: false
+  className: nginx
+  annotations: {}
+  hosts: []
+  tls: []
+
+secretRef: ""
+
+# File-based health check
+livenessProbe:
+  exec:
+    command:
+      - test
+      - -f
+      - /tmp/healthy
+  initialDelaySeconds: 10
+  periodSeconds: 10
+
+readinessProbe:
+  exec:
+    command:
+      - test
+      - -f
+      - /tmp/healthy
+  initialDelaySeconds: 5
+  periodSeconds: 5
+
+nodeSelector: {}
+
+tolerations: []
+
+affinity: {}

package/dist/templates/worker/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "{{name}}",
+  "version": "0.1.0",
+  "description": "{{description}}",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx watch src/index.ts",
+    "start": "node dist/index.js",
+    "lint": "eslint src --ext .ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "bullmq": "^5.0.0",
+    "ioredis": "^5.4.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/dist/templates/worker/src/index.ts

@@ -0,0 +1,185 @@
+import { Worker, Queue, Job } from 'bullmq'
+import { writeFile, unlink } from 'node:fs/promises'
+import { z } from 'zod'
+
+const SERVICE_NAME = '{{name}}'
+const QUEUE_NAME = process.env.QUEUE_NAME || '{{name}}-jobs'
+const HEALTH_FILE = '/tmp/healthy'
+
+// Redis connection configuration
+const redisConnection = {
+  host: process.env.REDIS_HOST || 'localhost',
+  port: parseInt(process.env.REDIS_PORT || '6379', 10),
+  password: process.env.REDIS_PASSWORD,
+}
+
+// Job data schema
+const JobDataSchema = z.object({
+  type: z.enum(['email', 'report', 'sync', 'cleanup']),
+  payload: z.record(z.unknown()),
+  priority: z.number().int().min(1).max(10).optional().default(5),
+})
+
+type JobData = z.infer<typeof JobDataSchema>
+
+// Job result type
+interface JobResult {
+  success: boolean
+  processedAt: string
+  duration: number
+  details?: Record<string, unknown>
+}
+
+// Process different job types
+async function processJob(job: Job<JobData>): Promise<JobResult> {
+  const startTime = Date.now()
+  const { type, payload } = job.data
+
+  process.stdout.write(`Processing ${type} job ${job.id}\n`)
+
+  try {
+    switch (type) {
+      case 'email':
+        await processEmailJob(payload)
+        break
+      case 'report':
+        await processReportJob(payload)
+        break
+      case 'sync':
+        await processSyncJob(payload)
+        break
+      case 'cleanup':
+        await processCleanupJob(payload)
+        break
+    }
+
+    const duration = Date.now() - startTime
+    process.stdout.write(`Completed ${type} job ${job.id} in ${duration}ms\n`)
+
+    return {
+      success: true,
+      processedAt: new Date().toISOString(),
+      duration,
+    }
+  } catch (error) {
+    const err = error as Error
+    process.stderr.write(`Failed ${type} job ${job.id}: ${err.message}\n`)
+    throw error
+  }
+}
+
+// Example job processors
+async function processEmailJob(payload: Record<string, unknown>): Promise<void> {
+  // Simulate email sending
+  await delay(100)
+  process.stdout.write(`Sent email to ${payload.to}\n`)
+}
+
+async function processReportJob(payload: Record<string, unknown>): Promise<void> {
+  // Simulate report generation
+  await delay(500)
+  process.stdout.write(`Generated report: ${payload.reportType}\n`)
+}
+
+async function processSyncJob(payload: Record<string, unknown>): Promise<void> {
+  // Simulate data sync
+  await delay(200)
+  process.stdout.write(`Synced data from ${payload.source}\n`)
+}
+
+async function processCleanupJob(payload: Record<string, unknown>): Promise<void> {
+  // Simulate cleanup
+  await delay(50)
+  process.stdout.write(`Cleaned up ${payload.target}\n`)
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+// Health check via file
+async function setHealthy(healthy: boolean): Promise<void> {
+  if (healthy) {
+    await writeFile(HEALTH_FILE, new Date().toISOString())
+  } else {
+    try {
+      await unlink(HEALTH_FILE)
+    } catch {
+      // File may not exist
+    }
+  }
+}
+
+// Main worker setup
+async function main(): Promise<void> {
+  process.stdout.write(`Starting ${SERVICE_NAME} worker\n`)
+  process.stdout.write(`Connecting to Redis at ${redisConnection.host}:${redisConnection.port}\n`)
+  process.stdout.write(`Listening on queue: ${QUEUE_NAME}\n`)
+
+  // Create the worker
+  const worker = new Worker<JobData, JobResult>(
+    QUEUE_NAME,
+    async (job) => {
+      // Validate job data
+      const result = JobDataSchema.safeParse(job.data)
+      if (!result.success) {
+        throw new Error(`Invalid job data: ${result.error.message}`)
+      }
+      return processJob(job)
+    },
+    {
+      connection: redisConnection,
+      concurrency: parseInt(process.env.WORKER_CONCURRENCY || '5', 10),
+    }
+  )
+
+  // Event handlers
+  worker.on('ready', async () => {
+    process.stdout.write('Worker is ready and listening for jobs\n')
+    await setHealthy(true)
+  })
+
+  worker.on('completed', (job, result) => {
+    process.stdout.write(`Job ${job.id} completed: ${JSON.stringify(result)}\n`)
+  })
+
+  worker.on('failed', (job, error) => {
+    process.stderr.write(`Job ${job?.id} failed: ${error.message}\n`)
+  })
+
+  worker.on('error', async (error) => {
+    process.stderr.write(`Worker error: ${error.message}\n`)
+    await setHealthy(false)
+  })
+
+  // Graceful shutdown
+  async function shutdown(): Promise<void> {
+    process.stdout.write('Shutting down worker...\n')
+    await setHealthy(false)
+    await worker.close()
+    process.exit(0)
+  }
+
+  process.on('SIGTERM', shutdown)
+  process.on('SIGINT', shutdown)
+
+  // Example: Create queue for adding jobs (usually done by another service)
+  const queue = new Queue<JobData>(QUEUE_NAME, { connection: redisConnection })
+
+  // Add a test job in development
+  if (process.env.NODE_ENV !== 'production') {
+    await queue.add('test-job', {
+      type: 'email',
+      payload: { to: 'test@example.com', subject: 'Test' },
+      priority: 5,
+    })
+    process.stdout.write('Added test job to queue\n')
+  }
+
+  await queue.close()
+}
+
+main().catch((error) => {
+  process.stderr.write(`Fatal error: ${error.message}\n`)
+  process.exit(1)
+})

package/dist/templates/worker/tsconfig.json

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