@crossdelta/infrastructure 0.2.24 → 0.2.26

package/bin/generate-env.ts

@@ -0,0 +1,178 @@
+#!/usr/bin/env bun
+/**
+ * Generate environment variables for local development.
+ *
+ * This script:
+ * 1. Loads secrets from Pulumi config (dev stack) if available
+ * 2. Discovers services from infra/services/*.ts (parses files without importing)
+ * 3. Generates service URLs and ports for localhost
+ * 4. Writes .env.local to the workspace root
+ *
+ * Usage: generate-env [--no-pulumi]
+ */
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+type PulumiConfigEntry = {
+  value?: string
+  secret?: boolean
+}
+
+interface MinimalServiceConfig {
+  name: string
+  containerPort?: number
+  httpPort?: number
+  internalPorts?: number[]
+  internalUrl?: string
+}
+
+const toEnvKey = (name: string): string => name.toUpperCase().replace(/-/g, '_')
+
+const resolveNumber = (value: string, fileContent: string): number | undefined => {
+  const literal = Number.parseInt(value, 10)
+  if (!Number.isNaN(literal)) return literal
+
+  const varMatch = fileContent.match(new RegExp(`(?:const|let|var)\\s+${value}\\s*=\\s*(\\d+)`))
+  return varMatch?.[1] ? Number.parseInt(varMatch[1], 10) : undefined
+}
+
+const extract = {
+  string: (content: string, pattern: RegExp): string | undefined =>
+    content.match(pattern)?.[1],
+
+  number: (content: string, pattern: RegExp): number | undefined => {
+    const match = content.match(pattern)?.[1]
+    return match ? resolveNumber(match, content) : undefined
+  },
+
+  numberArray: (content: string, pattern: RegExp): number[] | undefined => {
+    const match = content.match(pattern)?.[1]
+    if (!match) return undefined
+
+    const numbers = match
+      .split(',')
+      .map((v) => resolveNumber(v.trim(), content))
+      .filter((n): n is number => n !== undefined)
+
+    return numbers.length > 0 ? numbers : undefined
+  },
+}
+
+const findWorkspaceRoot = (): string => {
+  let dir = process.cwd()
+  while (!existsSync(join(dir, 'bun.lock')) && !existsSync(join(dir, 'package-lock.json'))) {
+    const parent = join(dir, '..')
+    if (parent === dir) throw new Error('Could not locate workspace root')
+    dir = parent
+  }
+  return dir
+}
+
+const loadPulumiConfig = async (infraDir: string, stack: string): Promise<string[]> => {
+  try {
+    const result = Bun.spawnSync(['pulumi', 'config', '--show-secrets', '--json', '--stack', stack, '--cwd', infraDir])
+    if (result.exitCode !== 0) return []
+    
+    const config = JSON.parse(result.stdout.toString()) as Record<string, PulumiConfigEntry>
+
+    return Object.entries(config)
+      .filter(([key]) => key.includes(':'))
+      .filter(([, entry]) => entry.value !== undefined && entry.value !== null && entry.value !== 'undefined')
+      .map(([fullKey, entry]) => {
+        const [, rawKey] = fullKey.split(':')
+        return `${rawKey}=${entry.value}`
+      })
+  } catch {
+    return []
+  }
+}
+
+const discoverServices = (servicesDir: string): MinimalServiceConfig[] => {
+  if (!existsSync(servicesDir)) return []
+  
+  const files = readdirSync(servicesDir).filter(
+    (file) => file.endsWith('.ts') && file !== 'index.ts'
+  )
+
+  return files.map((file) => {
+    const content = readFileSync(join(servicesDir, file), 'utf-8')
+
+    return {
+      name: extract.string(content, /name:\s*['"]([^'"]+)['"]/) ?? file.replace('.ts', ''),
+      containerPort: extract.number(content, /containerPort:\s*(\w+)/),
+      httpPort: extract.number(content, /httpPort:\s*(\w+)/),
+      internalPorts: extract.numberArray(content, /internalPorts:\s*\[([^\]]+)\]/),
+      internalUrl: extract.string(content, /internalUrl:\s*[`'"]([^`'"]+)[`'"]/),
+    }
+  })
+}
+
+const getServicePort = (config: MinimalServiceConfig): number | undefined => {
+  if (config.containerPort) return config.containerPort
+  if (config.httpPort) return config.httpPort
+  if (config.internalPorts?.[0]) return config.internalPorts[0]
+  return undefined
+}
+
+const getLocalUrl = (config: MinimalServiceConfig): string | undefined => {
+  const port = getServicePort(config)
+  if (!port) return undefined
+
+  if (config.internalUrl) {
+    const protocolMatch = config.internalUrl.match(/^(\w+):\/\//)
+    if (protocolMatch) {
+      return `${protocolMatch[1]}://localhost:${port}`
+    }
+  }
+
+  return `http://localhost:${port}`
+}
+
+const main = async () => {
+  const noPulumi = process.argv.includes('--no-pulumi')
+  const workspaceRootDir = findWorkspaceRoot()
+  const infraDir = join(workspaceRootDir, 'infra')
+  const servicesDir = join(infraDir, 'services')
+
+  const envLines: string[] = ['# Generated .env.local']
+
+  // Load Pulumi secrets if available and not disabled
+  if (!noPulumi && existsSync(join(infraDir, 'Pulumi.yaml'))) {
+    const pulumiEnvs = await loadPulumiConfig(infraDir, 'dev')
+    if (pulumiEnvs.length > 0) {
+      envLines.push('', '# Pulumi Secrets')
+      envLines.push(...pulumiEnvs)
+    }
+  }
+
+  // Discover services
+  const serviceConfigs = discoverServices(servicesDir)
+
+  if (serviceConfigs.length > 0) {
+    envLines.push('', '# Service URLs')
+    for (const config of serviceConfigs) {
+      const url = getLocalUrl(config)
+      if (url) {
+        envLines.push(`${toEnvKey(config.name)}_URL=${url}`)
+      }
+    }
+
+    envLines.push('', '# Service Ports')
+    for (const config of serviceConfigs) {
+      const port = getServicePort(config)
+      if (port) {
+        envLines.push(`${toEnvKey(config.name)}_PORT=${port}`)
+      }
+    }
+
+    console.log(`✅ Discovered ${serviceConfigs.length} services`)
+  }
+
+  writeFileSync(join(workspaceRootDir, '.env.local'), `${envLines.join('\n')}\n`)
+  console.log(`✅ .env.local generated at ${workspaceRootDir}`)
+}
+
+main().catch((err) => {
+  console.error('❌', err.message)
+  process.exit(1)
+})

package/dist/helpers/index.d.ts

@@ -3,6 +3,7 @@ export * from './discover-services';
 export * from './docker-hub-image';
 export * from './droplet-builder';
 export * from './image';
+export * from './otel';
 export * from './service-builder';
 export * from './service-runtime';
 export * from './service-urls';

package/dist/helpers/otel.d.ts

@@ -0,0 +1,62 @@
+import type * as pulumi from '@pulumi/pulumi';
+/**
+ * OpenTelemetry configuration for OTLP export.
+ */
+export interface OtelConfig {
+    /** OTLP endpoint for traces (e.g., https://in-otel.logs.betterstack.com/v1/traces) */
+    tracesEndpoint?: pulumi.Input<string>;
+    /** OTLP endpoint for metrics (e.g., https://in-otel.logs.betterstack.com/v1/metrics) */
+    metricsEndpoint?: pulumi.Input<string>;
+    /** OTLP headers (e.g., "Authorization=Bearer xxx") */
+    headers?: pulumi.Input<string>;
+    /** Deployment environment (e.g., "production", "staging") */
+    environment?: string;
+}
+/**
+ * Builds OpenTelemetry environment variables for a service.
+ *
+ * @param serviceName - Unique service name (e.g., "orderboss-storefront")
+ * @param config - OTel configuration from Pulumi config
+ * @returns Record of environment variables for OTel SDK auto-instrumentation
+ *
+ * @example
+ * ```typescript
+ * const otelConfig = {
+ *   tracesEndpoint: cfg.get('otelTracesEndpoint'),
+ *   metricsEndpoint: cfg.get('otelMetricsEndpoint'),
+ *   headers: cfg.getSecret('otelHeaders'),
+ *   environment: 'production',
+ * }
+ *
+ * const serviceConfig = {
+ *   name: 'orders',
+ *   env: {
+ *     ...buildOtelEnv('orderboss-orders', otelConfig),
+ *     // other env vars
+ *   },
+ * }
+ * ```
+ */
+export declare function buildOtelEnv(serviceName: string, config: OtelConfig): Record<string, pulumi.Input<string>>;
+/**
+ * Creates a function that builds OTel env vars with pre-configured endpoints.
+ * Useful for applying the same OTel config to multiple services.
+ *
+ * @param config - OTel configuration from Pulumi config
+ * @returns Function that takes a service name and returns OTel env vars
+ *
+ * @example
+ * ```typescript
+ * const withOtelEnv = createOtelEnvBuilder({
+ *   tracesEndpoint: cfg.get('otelTracesEndpoint'),
+ *   headers: cfg.getSecret('otelHeaders'),
+ *   environment: getStack(),
+ * })
+ *
+ * // In each service config:
+ * env: {
+ *   ...withOtelEnv('orderboss-orders'),
+ * }
+ * ```
+ */
+export declare function createOtelEnvBuilder(config: OtelConfig): (serviceName: string) => Record<string, pulumi.Input<string>>;