otavia 0.1.0

package/src/utils/env.test.ts

@@ -0,0 +1,74 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { describe, expect, test } from "bun:test";
+import { loadEnvForCell } from "./env.js";
+
+function write(path: string, content: string): void {
+  writeFileSync(path, content.trim() + "\n", "utf-8");
+}
+
+describe("loadEnvForCell", () => {
+  test("deploy stage uses .env + .env.deploy and skips .env.local", () => {
+    const root = mkdtempSync(join(tmpdir(), "otavia-env-deploy-"));
+    try {
+      const cellDir = join(root, "apps", "demo");
+      mkdirSync(cellDir, { recursive: true });
+      write(join(root, ".env"), "SSO_BASE_URL=http://localhost:7100/sso\nSHARED=base");
+      write(join(root, ".env.deploy"), "SSO_BASE_URL=https://beta.example.com/sso");
+      write(join(root, ".env.local"), "SSO_BASE_URL=http://local-override.invalid/sso");
+      write(join(cellDir, ".env"), "CELL_ONLY=1");
+      write(join(cellDir, ".env.deploy"), "DEPLOY_ONLY=1");
+      write(join(cellDir, ".env.local"), "CELL_LOCAL_ONLY=1");
+
+      const env = loadEnvForCell(root, "demo", { stage: "deploy" });
+      expect(env.SSO_BASE_URL).toBe("https://beta.example.com/sso");
+      expect(env.SHARED).toBe("base");
+      expect(env.CELL_ONLY).toBe("1");
+      expect(env.DEPLOY_ONLY).toBe("1");
+      expect(env.CELL_LOCAL_ONLY).toBeUndefined();
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("dev stage applies .env.dev and .env.local overrides", () => {
+    const root = mkdtempSync(join(tmpdir(), "otavia-env-dev-"));
+    try {
+      const cellDir = join(root, "apps", "demo");
+      mkdirSync(cellDir, { recursive: true });
+      write(join(root, ".env"), "SSO_BASE_URL=http://localhost:7100/sso\nLOG_LEVEL=info");
+      write(join(root, ".env.dev"), "LOG_LEVEL=debug");
+      write(join(root, ".env.local"), "LOG_LEVEL=trace");
+      write(join(cellDir, ".env"), "LOG_LEVEL=warn");
+      write(join(cellDir, ".env.dev"), "LOG_LEVEL=error");
+      write(join(cellDir, ".env.local"), "LOG_LEVEL=fatal");
+
+      const env = loadEnvForCell(root, cellDir, { stage: "dev" });
+      expect(env.SSO_BASE_URL).toBe("http://localhost:7100/sso");
+      expect(env.LOG_LEVEL).toBe("fatal");
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("test stage applies .env.test and skips .env.local", () => {
+    const root = mkdtempSync(join(tmpdir(), "otavia-env-test-"));
+    try {
+      const cellDir = join(root, "apps", "demo");
+      mkdirSync(cellDir, { recursive: true });
+      write(join(root, ".env"), "A=base");
+      write(join(root, ".env.test"), "A=test");
+      write(join(root, ".env.local"), "A=local");
+      write(join(cellDir, ".env"), "B=cell");
+      write(join(cellDir, ".env.test"), "B=cell-test");
+      write(join(cellDir, ".env.local"), "B=cell-local");
+
+      const env = loadEnvForCell(root, "demo", { stage: "test" });
+      expect(env.A).toBe("test");
+      expect(env.B).toBe("cell-test");
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});

package/src/utils/env.ts

@@ -0,0 +1,79 @@
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+
+/** Parse .env file content into a key-value map. */
+export function parseEnvFile(content: string): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    let value = trimmed.slice(eqIdx + 1).trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    result[key] = value;
+  }
+  return result;
+}
+
+type EnvStage = "dev" | "test" | "deploy";
+
+function normalizeStage(stage?: string): EnvStage | undefined {
+  if (!stage) return undefined;
+  if (stage === "cloud") return "deploy";
+  if (stage === "dev" || stage === "test" || stage === "deploy") return stage;
+  return undefined;
+}
+
+function resolveCellDirForEnv(rootDir: string, cellIdOrDir: string): string {
+  if (isAbsolute(cellIdOrDir)) return cellIdOrDir;
+  const cellsPath = resolve(rootDir, "cells", cellIdOrDir);
+  const appsPath = resolve(rootDir, "apps", cellIdOrDir);
+  if (existsSync(cellsPath)) return cellsPath;
+  if (existsSync(appsPath)) return appsPath;
+  return cellsPath;
+}
+
+function loadEnvFile(path: string, target: Record<string, string>): void {
+  if (!existsSync(path)) return;
+  Object.assign(target, parseEnvFile(readFileSync(path, "utf-8")));
+}
+
+/**
+ * Load layered env files with stage overrides.
+ * Order (later overrides earlier):
+ *   1) root: .env, .env.<stage>, .env.local (dev/default only)
+ *   2) cell: .env, .env.<stage>, .env.local (dev/default only)
+ */
+export function loadEnvForCell(
+  rootDir: string,
+  cellIdOrDir: string,
+  options?: { stage?: string }
+): Record<string, string> {
+  const merged: Record<string, string> = {};
+  const stage = normalizeStage(options?.stage);
+  const useLocalOverrides = stage !== "deploy" && stage !== "test";
+  const rootEnv = resolve(rootDir, ".env");
+  const rootStageEnv = stage ? resolve(rootDir, `.env.${stage}`) : "";
+  const rootEnvLocal = resolve(rootDir, ".env.local");
+  const cellDir = resolveCellDirForEnv(rootDir, cellIdOrDir);
+  const cellEnv = resolve(cellDir, ".env");
+  const cellStageEnv = stage ? resolve(cellDir, `.env.${stage}`) : "";
+  const cellEnvLocal = resolve(cellDir, ".env.local");
+
+  loadEnvFile(rootEnv, merged);
+  if (rootStageEnv) loadEnvFile(rootStageEnv, merged);
+  if (useLocalOverrides) loadEnvFile(rootEnvLocal, merged);
+
+  loadEnvFile(cellEnv, merged);
+  if (cellStageEnv) loadEnvFile(cellStageEnv, merged);
+  if (useLocalOverrides) loadEnvFile(cellEnvLocal, merged);
+
+  return merged;
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "target": "ESNext",
+    "lib": ["ESNext", "DOM"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "skipLibCheck": true,
+    "types": ["bun", "node"]
+  },
+  "include": ["src/**/*"]
+}