@davidvornholt/standards 0.21.0 → 0.22.0

package/src/dev-env-plain-layer.ts

@@ -0,0 +1,53 @@
+// Reads one plain (unencrypted) dev env layer from disk, distinguishing a
+// missing optional file from an unreadable or unparsable one.
+
+import { lstatSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parseYaml } from './yaml-parse';
+
+export type DevEnvPlainInput = { readonly raw: unknown } | null;
+
+export type PlainLayerRead = {
+  readonly input: DevEnvPlainInput;
+  readonly present: boolean;
+  readonly problems: ReadonlyArray<string>;
+};
+
+const isMissingPathError = (error: unknown): boolean =>
+  (error as { readonly code?: unknown } | null)?.code === 'ENOENT';
+
+export const readPlainLayer = (
+  consumer: string,
+  rel: string,
+): PlainLayerRead => {
+  const path = join(consumer, rel);
+  try {
+    lstatSync(path);
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      return { input: null, present: false, problems: [] };
+    }
+    const detail = error instanceof Error ? error.message : String(error);
+    return {
+      input: null,
+      present: true,
+      problems: [`could not inspect ${rel}: ${detail}`],
+    };
+  }
+  let raw: string;
+  try {
+    raw = readFileSync(path, 'utf8');
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return {
+      input: null,
+      present: true,
+      problems: [`could not read ${rel}: ${detail}`],
+    };
+  }
+  const parsed = parseYaml(raw, rel);
+  if (parsed.problem !== null) {
+    return { input: null, present: true, problems: [parsed.problem] };
+  }
+  return { input: { raw: parsed.value ?? {} }, present: true, problems: [] };
+};

package/src/dev-env.ts

@@ -1,5 +1,10 @@
-import { existsSync, lstatSync, readFileSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import { join } from 'node:path';
+import {
+  type DevEnvRunOptions,
+  renderDevEnvPreservingUnsafeReferences,
+} from './dev-env-brokered-preserve';
+import { resolveBrokeredReferences } from './dev-env-brokered-resolve';
 import { composeDevEnv } from './dev-env-compose';
 import {
   type DevEnvRemoval,
@@ -8,64 +13,28 @@ import {
 } from './dev-env-destination';
 import { devEnvGitIgnoreProblem } from './dev-env-destination-gitignore';
 import { parseDevEnvDocument } from './dev-env-document';
-import { renderDotenv } from './dev-env-dotenv';
+import type { DevEnvPlainInput } from './dev-env-plain-layer';
+import { readPlainLayer } from './dev-env-plain-layer';
 import { planDevEnvRemovals } from './dev-env-reconciliation';
 import { DEV_SECRETS_FILE, readDevSecrets } from './dev-env-secrets';
 import { applyDevEnvChanges } from './dev-env-transaction';
-import { parseYaml } from './yaml-parse';
 
 export const DEV_CONFIG_FILE = 'config/dev.yaml';
 export const DEV_LOCAL_FILE = 'config/dev.local.yaml';
 
-export type DevEnvPlainInput = { readonly raw: unknown } | null;
-
 export type DevEnvInputs = {
   readonly config: DevEnvPlainInput;
   readonly secrets: unknown;
   readonly local: DevEnvPlainInput;
 };
 
-const isMissingPathError = (error: unknown): boolean =>
-  (error as { readonly code?: unknown } | null)?.code === 'ENOENT';
-
-const readPlainLayer = (consumer: string, rel: string) => {
-  const path = join(consumer, rel);
-  try {
-    lstatSync(path);
-  } catch (error) {
-    if (isMissingPathError(error)) {
-      return { input: null, present: false, problems: [] };
-    }
-    const detail = error instanceof Error ? error.message : String(error);
-    return {
-      input: null,
-      present: true,
-      problems: [`could not inspect ${rel}: ${detail}`],
-    };
-  }
-  let raw: string;
-  try {
-    raw = readFileSync(path, 'utf8');
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    return {
-      input: null,
-      present: true,
-      problems: [`could not read ${rel}: ${detail}`],
-    };
-  }
-  const parsed = parseYaml(raw, rel);
-  if (parsed.problem !== null) {
-    return { input: null, present: true, problems: [parsed.problem] };
-  }
-  return { input: { raw: parsed.value ?? {} }, present: true, problems: [] };
-};
-
 const documentProblems = (
   source: string,
   input: DevEnvPlainInput,
 ): ReadonlyArray<string> =>
-  input === null ? [] : parseDevEnvDocument(input.raw, source).problems;
+  input === null
+    ? []
+    : parseDevEnvDocument(input.raw, source, 'configuration').problems;
 
 export type DevEnvPlan = {
   readonly writes: ReadonlyArray<DevEnvWrite>;
@@ -76,35 +45,60 @@ export type DevEnvPlan = {
 export const planDevEnvChanges = (
   consumer: string,
   inputs: DevEnvInputs,
+  options: DevEnvRunOptions = { preservedBrokeredReferences: new Set() },
 ): DevEnvPlan => {
   const layer = (source: string, input: DevEnvPlainInput) =>
     input === null
       ? null
-      : { source, document: parseDevEnvDocument(input.raw, source) };
+      : {
+          source,
+          document: parseDevEnvDocument(input.raw, source, 'configuration'),
+        };
   const composed = composeDevEnv(
     layer(DEV_CONFIG_FILE, inputs.config),
     {
       source: DEV_SECRETS_FILE,
-      document: parseDevEnvDocument(inputs.secrets, DEV_SECRETS_FILE),
+      document: parseDevEnvDocument(
+        inputs.secrets,
+        DEV_SECRETS_FILE,
+        'secrets',
+      ),
     },
     layer(DEV_LOCAL_FILE, inputs.local),
   );
-  const problems: Array<string> = [...composed.problems];
+  const resolved = resolveBrokeredReferences(
+    consumer,
+    composed.targets,
+    composed.brokeredReferences,
+    options.preservedBrokeredReferences,
+  );
+  const problems: Array<string> = [...composed.problems, ...resolved.problems];
   const writes: Array<DevEnvWrite> = [];
-  for (const target of composed.targets) {
+  for (const target of resolved.targets) {
     const workspaceDir = `${target.group}/${target.workspace}`;
     const rel = `${workspaceDir}/.env.local`;
     if (existsSync(join(consumer, workspaceDir, 'package.json'))) {
       const ignoreProblem = devEnvGitIgnoreProblem(consumer, rel);
       if (ignoreProblem === null) {
-        writes.push({
+        const composedTarget = composed.targets.find(
+          (candidate) =>
+            candidate.group === target.group &&
+            candidate.workspace === target.workspace,
+        );
+        const rendered = renderDevEnvPreservingUnsafeReferences({
+          consumer,
           rel,
-          content: renderDotenv(
-            `${target.group}.${target.workspace}`,
-            target.sources,
-            target.env,
-          ),
+          sourcePath: `${target.group}.${target.workspace}`,
+          sources: target.sources,
+          resolvedEnv: target.env,
+          composedEnv: composedTarget?.env ?? {},
+          preservedReferences: options.preservedBrokeredReferences,
         });
+        if (rendered.ok) {
+          writes.push({ rel, content: rendered.content });
+        } else {
+          problems.push(rendered.problem);
+        }
       } else {
         problems.push(ignoreProblem);
       }
@@ -122,7 +116,10 @@ export const planDevEnvChanges = (
   };
 };
 
-export const runDevEnv = async (consumer: string): Promise<boolean> => {
+export const runDevEnv = async (
+  consumer: string,
+  options: DevEnvRunOptions = { preservedBrokeredReferences: new Set() },
+): Promise<boolean> => {
   const config = readPlainLayer(consumer, DEV_CONFIG_FILE);
   const secrets = readDevSecrets(consumer);
   const local = readPlainLayer(consumer, DEV_LOCAL_FILE);
@@ -136,7 +133,7 @@ export const runDevEnv = async (consumer: string): Promise<boolean> => {
     ...(localIgnoreProblem === null ? [] : [localIgnoreProblem]),
     ...documentProblems(DEV_CONFIG_FILE, config.input),
     ...(secrets.ok
-      ? parseDevEnvDocument(secrets.value, DEV_SECRETS_FILE).problems
+      ? parseDevEnvDocument(secrets.value, DEV_SECRETS_FILE, 'secrets').problems
       : []),
     ...documentProblems(DEV_LOCAL_FILE, local.input),
   ];
@@ -145,11 +142,15 @@ export const runDevEnv = async (consumer: string): Promise<boolean> => {
     console.error(inputProblems.map((problem) => `  - ${problem}`).join('\n'));
     return false;
   }
-  const plan = planDevEnvChanges(consumer, {
-    config: config.input,
-    secrets: secrets.value,
-    local: local.input,
-  });
+  const plan = planDevEnvChanges(
+    consumer,
+    {
+      config: config.input,
+      secrets: secrets.value,
+      local: local.input,
+    },
+    options,
+  );
   const problems = [
     ...plan.problems,
     ...(await devEnvDestinationProblems(consumer, [