@crossdelta/infrastructure 0.3.2 → 0.4.1

package/README.md

@@ -89,15 +89,27 @@ The architecture is **provider-agnostic** - runtime components (NATS, Ingress, C
 npm install @crossdelta/infrastructure
 ```
 
-## Quick Start
+### Peer Dependencies
 
-### 1. Install dependencies
+This package requires Pulumi packages as peer dependencies. Install them based on your target cloud provider:
 
 ```bash
-npm install @crossdelta/infrastructure @pulumi/pulumi @pulumi/kubernetes @pulumi/digitalocean
+# Required - Pulumi core and Kubernetes
+npm install @pulumi/pulumi @pulumi/kubernetes
+
+# Optional - DigitalOcean provider (for DOKS)
+npm install @pulumi/digitalocean
 ```
 
-### 2. Create service configs
+| Package | Required | Description |
+|---------|----------|-------------|
+| `@pulumi/pulumi` | ✅ Yes | Pulumi core SDK |
+| `@pulumi/kubernetes` | ✅ Yes | Kubernetes resources |
+| `@pulumi/digitalocean` | Optional | DigitalOcean provider (DOKS, VPC, etc.) |
+
+## Quick Start
+
+### 1. Create service configs
 
 ```typescript
 // infra/services/orders.ts
@@ -135,7 +147,7 @@ const config: K8sServiceConfig = {
 export default config
 ```
 
-### 3. Create your Pulumi infrastructure
+### 2. Create your Pulumi infrastructure
 
 ```typescript
 // infra/index.ts

package/bin/generate-env.mjs

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+
+// bin/generate-env.ts
+import { execSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var toEnvKey = (name) => name.toUpperCase().replace(/-/g, "_");
+var resolveNumber = (value, fileContent) => {
+  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;
+};
+var extract = {
+  string: (content, pattern) => content.match(pattern)?.[1],
+  number: (content, pattern) => {
+    const match = content.match(pattern)?.[1];
+    return match ? resolveNumber(match, content) : undefined;
+  },
+  numberArray: (content, pattern) => {
+    const match = content.match(pattern)?.[1];
+    if (!match)
+      return;
+    const numbers = match.split(",").map((v) => resolveNumber(v.trim(), content)).filter((n) => n !== undefined);
+    return numbers.length > 0 ? numbers : undefined;
+  }
+};
+var LOCK_FILES = ["bun.lock", "bun.lockb", "package-lock.json", "pnpm-lock.yaml", "yarn.lock"];
+var hasLockFile = (dir) => LOCK_FILES.some((file) => existsSync(join(dir, file)));
+var findWorkspaceRoot = () => {
+  let dir = process.cwd();
+  while (!hasLockFile(dir)) {
+    const parent = join(dir, "..");
+    if (parent === dir)
+      throw new Error("Could not locate workspace root");
+    dir = parent;
+  }
+  return dir;
+};
+var loadPulumiConfig = async (infraDir, stack) => {
+  try {
+    const stdout = execSync(`pulumi config --show-secrets --json --stack ${stack} --cwd ${infraDir}`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const config = JSON.parse(stdout);
+    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 [];
+  }
+};
+var discoverServices = (servicesDir) => {
+  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");
+    const portsApiMatch = content.match(/ports\(\)\.(?:http|https|grpc|primary)\((\d+)\)/) || content.match(/ports\(\)\.add\((\d+)/);
+    return {
+      name: extract.string(content, /name:\s*['"]([^'"]+)['"]/) ?? file.replace(".ts", ""),
+      primaryPort: portsApiMatch?.[1] ? Number.parseInt(portsApiMatch[1], 10) : undefined,
+      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*[`'"]([^`'"]+)[`'"]/)
+    };
+  });
+};
+var getServicePort = (config) => {
+  if (config.primaryPort)
+    return config.primaryPort;
+  if (config.containerPort)
+    return config.containerPort;
+  if (config.httpPort)
+    return config.httpPort;
+  if (config.internalPorts?.[0])
+    return config.internalPorts[0];
+  return;
+};
+var getLocalUrl = (config) => {
+  const port = getServicePort(config);
+  if (!port)
+    return;
+  if (config.internalUrl) {
+    const protocolMatch = config.internalUrl.match(/^(\w+):\/\//);
+    if (protocolMatch) {
+      return `${protocolMatch[1]}://localhost:${port}`;
+    }
+  }
+  return `http://localhost:${port}`;
+};
+var main = async () => {
+  const noPulumi = process.argv.includes("--no-pulumi");
+  const workspaceRootDir = findWorkspaceRoot();
+  const infraDir = join(workspaceRootDir, "infra");
+  const servicesDir = join(infraDir, "services");
+  const envLines = ["# Generated .env.local"];
+  if (!noPulumi && existsSync(join(infraDir, "Pulumi.yaml"))) {
+    const pulumiEnvs = await loadPulumiConfig(infraDir, "dev");
+    if (pulumiEnvs.length > 0) {
+      envLines.push("", "# Pulumi Secrets");
+      envLines.push(...pulumiEnvs);
+    }
+  }
+  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(`
+`)}
+`);
+  console.log(`✅ .env.local generated at ${workspaceRootDir}`);
+};
+main().catch((err) => {
+  console.error("❌", err.message);
+  process.exit(1);
+});

package/bin/generate-env.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 /**
  * Generate environment variables for local development.
  *
@@ -10,6 +10,7 @@
  *
  * Usage: generate-env [--no-pulumi]
  */
+import { execSync } from 'node:child_process'
 import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 
@@ -58,9 +59,13 @@ const extract = {
   },
 }
 
+const LOCK_FILES = ['bun.lock', 'bun.lockb', 'package-lock.json', 'pnpm-lock.yaml', 'yarn.lock']
+
+const hasLockFile = (dir: string): boolean => LOCK_FILES.some((file) => existsSync(join(dir, file)))
+
 const findWorkspaceRoot = (): string => {
   let dir = process.cwd()
-  while (!existsSync(join(dir, 'bun.lock')) && !existsSync(join(dir, 'package-lock.json'))) {
+  while (!hasLockFile(dir)) {
     const parent = join(dir, '..')
     if (parent === dir) throw new Error('Could not locate workspace root')
     dir = parent
@@ -70,10 +75,12 @@ const findWorkspaceRoot = (): string => {
 
 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 stdout = execSync(`pulumi config --show-secrets --json --stack ${stack} --cwd ${infraDir}`, {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
 
-    const config = JSON.parse(result.stdout.toString()) as Record<string, PulumiConfigEntry>
+    const config = JSON.parse(stdout) as Record<string, PulumiConfigEntry>
 
     return Object.entries(config)
       .filter(([key]) => key.includes(':'))