@crossdelta/infrastructure 0.5.2 → 0.5.4

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", "yarn.lock", "pnpm-lock.yaml"];
+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/dist/helpers/streams.d.ts

@@ -48,8 +48,8 @@ export interface ValidationResult {
  *
  * const streams = collectStreamDefinitions(contracts)
  * // [
- * //   { stream: 'ORDERS', subjects: ['orders.created', 'orders.updated'] },
- * //   { stream: 'CUSTOMERS', subjects: ['customers.updated'] }
+ * //   { stream: 'ORDERS', subjects: ['order.created', 'order.updated'] },
+ * //   { stream: 'CUSTOMERS', subjects: ['customer.updated'] }
  * // ]
  * ```
  */