@notation/cli 0.11.1 → 0.14.0

package/dist/index.js

@@ -6,17 +6,23 @@ import { program } from "commander";
 // src/compile.ts
 import chokidar from "chokidar";
 import { glob } from "glob";
-import { log } from "console";
 import esbuild from "esbuild";
 import {
   functionInfraPlugin,
   functionRuntimePlugin
 } from "@notation/esbuild-plugins";
 import { filePaths } from "@notation/core";
-async function compile(entryPoint, watch2 = false) {
-  log(`${watch2 ? "Watching" : "Compiling"} infrastructure`, entryPoint);
+
+// src/logger.ts
+var defaultLogger = console;
+
+// src/compile.ts
+async function compile(entryPoint, opts = {}) {
+  const watch2 = opts.watch ?? false;
+  const logger = opts.logger ?? defaultLogger;
+  logger.info(`${watch2 ? "Watching" : "Compiling"} infrastructure`, entryPoint);
   await compileInfra(entryPoint, watch2);
-  log(`${watch2 ? "Watching" : "Compiling"} functions`);
+  logger.info(`${watch2 ? "Watching" : "Compiling"} functions`);
   const fnEntryPoints = await glob("runtime/**/*.fn.ts");
   let disposeFnCompiler = await compileFns(fnEntryPoints, watch2);
   if (!watch2) return;
@@ -72,59 +78,175 @@ async function compileFns(entryPoints, watch2 = false) {
 }
 
 // src/deploy.ts
-import { deployApp } from "@notation/core";
-async function deploy(entryPoint) {
-  await compile(entryPoint);
-  console.log(`Deploying ${entryPoint}`);
+import {
+  createLoggerReconcilerSubscriber,
+  createNdjsonEventEmitter,
+  deployApp
+} from "@notation/core";
+import { randomUUID } from "crypto";
+
+// src/stdio.ts
+function redirectStdoutToStderr() {
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  const write = (line) => {
+    originalWrite(line);
+  };
+  process.stdout.write = ((chunk, ...args) => process.stderr.write(
+    chunk,
+    ...args
+  ));
+  return {
+    write,
+    restore: () => {
+      process.stdout.write = originalWrite;
+    }
+  };
+}
+
+// src/deploy.ts
+async function deploy(entryPoint, opts = {}) {
+  const logger = opts.logger ?? defaultLogger;
+  const emit = opts.json ? createNdjsonEventEmitter(redirectStdoutToStderr().write) : createLoggerReconcilerSubscriber({ logger });
+  await compile(entryPoint, { logger });
+  logger.info(`Deploying ${entryPoint}`);
+  const executionId = opts.executionId ?? randomUUID();
+  logger.info(`Execution ID ${executionId}`);
+  await deployApp({ entryPoint, emit, executionId });
+}
+
+// src/destroy.ts
+import {
+  createLoggerReconcilerSubscriber as createLoggerReconcilerSubscriber2,
+  createNdjsonEventEmitter as createNdjsonEventEmitter2,
+  destroyApp
+} from "@notation/core";
+import { randomUUID as randomUUID2 } from "crypto";
+async function destroy(entryPoint, opts = {}) {
+  const logger = opts.logger ?? defaultLogger;
+  const emit = opts.json ? createNdjsonEventEmitter2(redirectStdoutToStderr().write) : createLoggerReconcilerSubscriber2({ logger });
+  await compile(entryPoint, { logger });
+  logger.info(`Destroying ${entryPoint}
+`);
+  const executionId = opts.executionId ?? randomUUID2();
+  logger.info(`Execution ID ${executionId}`);
+  await destroyApp({ entryPoint, emit, executionId });
+}
+
+// src/plan.ts
+import {
+  createLoggerReconcilerSubscriber as createLoggerReconcilerSubscriber3,
+  planApp
+} from "@notation/core";
+var decisionSymbols = {
+  create: "+",
+  update: "~",
+  replace: "-/+",
+  "drift-update": "~",
+  "drift-replace": "-/+",
+  "drift-recreate": "\xB1",
+  "delete-orphan": "-",
+  noop: " "
+};
+async function plan(entryPoint, opts = {}) {
+  const logger = opts.logger ?? defaultLogger;
+  const emit = createLoggerReconcilerSubscriber3({ logger });
+  if (opts.json) {
+    let result2;
+    const { restore } = redirectStdoutToStderr();
+    try {
+      await compile(entryPoint, { logger });
+      result2 = await planApp({
+        entryPoint,
+        emit
+      });
+    } finally {
+      restore();
+    }
+    process.stdout.write(`${JSON.stringify(result2, null, 2)}
+`);
+    return;
+  }
+  await compile(entryPoint, { logger });
+  logger.info(`Planning ${entryPoint}
+`);
+  const result = await planApp({
+    entryPoint,
+    emit
+  });
+  printPlanSummary(result, logger);
+}
+function printPlanSummary(result, logger) {
+  const changedNodes = result.nodes.filter((node) => node.decision !== "noop");
+  for (const node of changedNodes) {
+    logger.info(
+      `${decisionSymbols[node.decision]} ${node.decision} ${node.type} ${node.id}`
+    );
+    for (const field of node.replaceFields ?? []) {
+      logger.info(
+        field.known ? `    ${field.name} forces replacement` : `    ${field.name} unknown, may force replacement`
+      );
+    }
+  }
+  const count = (decision) => result.nodes.filter((node) => node.decision === decision).length;
+  const summary = [
+    `${count("create")} to create`,
+    `${count("update") + count("drift-update")} to update`,
+    `${count("replace") + count("drift-replace")} to replace`,
+    `${count("drift-recreate")} to recreate`,
+    `${count("delete-orphan")} to delete`,
+    `${count("noop")} unchanged`
+  ].join(", ");
+  logger.info(`${changedNodes.length > 0 ? "\n" : ""}Plan: ${summary}.`);
+}
+
+// src/run-with-error-handling.ts
+async function runWithErrorHandling(fn, opts) {
   try {
-    await deployApp(entryPoint);
-  } catch (err) {
-    if (err.name === "CredentialsProviderError") {
-      console.log(
+    await fn();
+    return 0;
+  } catch (error) {
+    if (error instanceof Error && error.name === "CredentialsProviderError") {
+      opts.logger.error(
         "\nAWS credentials not found.",
         "\n\nEnsure you have a default profile set up in ~/.aws/credentials.",
-        "\n\nIf using another profile run AWS_PROFILE=otherProfile notation deploy.\n"
+        `
+
+If using another profile run AWS_PROFILE=otherProfile notation ${opts.command}.
+`
       );
-      process.exit(1);
+      return 1;
     }
-    console.log(err);
-    process.exit(1);
+    opts.logger.error(error);
+    return 1;
   }
 }
 
-// src/destroy.ts
-import { destroyApp } from "@notation/core";
-async function destroy(entryPoint) {
-  await compile(entryPoint);
-  await destroyApp(entryPoint);
-}
-
 // src/visualise.ts
 import {
   createMermaidFlowChart,
   createMermaidLiveUrl,
   getResourceGraph
 } from "@notation/core";
-import { log as log2 } from "console";
-async function visualise(entryPoint) {
+async function visualise(entryPoint, logger = defaultLogger) {
   await compileInfra(entryPoint);
-  await generateGraph(entryPoint);
+  await generateGraph(entryPoint, logger);
 }
-async function generateGraph(entryPoint) {
-  log2(`Generating graph for ${entryPoint}`);
+async function generateGraph(entryPoint, logger = defaultLogger) {
+  logger.info(`Generating graph for ${entryPoint}`);
   const graph = await getResourceGraph(entryPoint);
   const chart = createMermaidFlowChart(graph.resourceGroups, graph.resources);
   const chartUrl = createMermaidLiveUrl(chart);
-  log2("\nGenerated infrastructure chart:\n");
-  log2(chartUrl);
+  logger.info("\nGenerated infrastructure chart:\n");
+  logger.info(chartUrl);
 }
 
 // src/watch.ts
 import chokidar2 from "chokidar";
-import { deployApp as deployApp2 } from "@notation/core";
+import { randomUUID as randomUUID3 } from "crypto";
+import { createLoggerReconcilerSubscriber as createLoggerReconcilerSubscriber4, deployApp as deployApp2 } from "@notation/core";
 var dotFilesRe = /(^|[\/\\])\../;
-async function watch(entryPoint) {
-  await compile(entryPoint, true);
+async function watch(entryPoint, logger = defaultLogger) {
+  await compile(entryPoint, { watch: true, logger });
   const watcher = chokidar2.watch("dist", {
     ignored: dotFilesRe,
     persistent: true
@@ -148,14 +270,21 @@ async function watch(entryPoint) {
       return;
     }
     isDeploying = true;
-    deployApp2(entryPoint, false).then(() => {
+    const executionId = randomUUID3();
+    logger.info(`Execution ID ${executionId}`);
+    deployApp2({
+      entryPoint,
+      executionId,
+      driftDetection: false,
+      emit: createLoggerReconcilerSubscriber4({ logger })
+    }).then(() => {
       isDeploying = false;
       if (deployQueued) {
         deployQueued = false;
         triggerDeploy();
       }
     }).catch((err) => {
-      console.error(err);
+      logger.error(err);
       isDeploying = false;
     });
   }
@@ -163,17 +292,30 @@ async function watch(entryPoint) {
 
 // src/index.ts
 import { startDashboardServer } from "@notation/dashboard";
+import { NodeDurableRuntime, resolveDeploymentId } from "@notation/core";
 program.command("compile").argument("<entryPoint>", "entryPoint").description("Compile Notation App").action(async (entryPoint) => {
   await compile(entryPoint);
 });
-program.command("dashboard").description("Start Notation Dashboard").action(async () => {
-  await startDashboardServer();
+program.command("dashboard").argument("<entryPoint>", "entryPoint").description("Start Notation Dashboard").action(async (entryPoint) => {
+  const runtime = new NodeDurableRuntime({
+    deploymentId: resolveDeploymentId(entryPoint)
+  });
+  await startDashboardServer({ state: runtime.state });
+});
+program.command("deploy").argument("<entryPoint>", "entryPoint").description("Deploy Notation App").option("--json", "stream reconciler events as NDJSON").option("--execution-id <id>", "resume a durable execution").action(async (entryPoint, options) => {
+  await deploy(entryPoint, {
+    json: options.json,
+    executionId: options.executionId
+  });
 });
-program.command("deploy").argument("<entryPoint>", "entryPoint").description("Deploy Notation App").action(async (entryPoint) => {
-  await deploy(entryPoint);
+program.command("destroy").argument("<entryPoint>", "entryPoint").description("Destroy Notation App").option("--json", "stream reconciler events as NDJSON").option("--execution-id <id>", "resume a durable execution").action(async (entryPoint, options) => {
+  await destroy(entryPoint, {
+    json: options.json,
+    executionId: options.executionId
+  });
 });
-program.command("destroy").argument("<entryPoint>", "entryPoint").description("Destroy Notation App").action(async (entryPoint) => {
-  await destroy(entryPoint);
+program.command("plan").argument("<entryPoint>", "entryPoint").description("Plan Notation App").option("--json", "print the plan as JSON").action(async (entryPoint, options) => {
+  await plan(entryPoint, { json: options.json });
 });
 program.command("viz").argument("<entryPoint>", "entryPoint").description("Visualise Notation App").action(async (entryPoint) => {
   await visualise(entryPoint);
@@ -181,4 +323,7 @@ program.command("viz").argument("<entryPoint>", "entryPoint").description("Visua
 program.command("watch").argument("<entryPoint>", "entryPoint").description("Watch Notation App").action(async (entryPoint) => {
   await watch(entryPoint);
 });
-program.parse(process.argv);
+process.exitCode = await runWithErrorHandling(
+  () => program.parseAsync(process.argv),
+  { logger: defaultLogger, command: process.argv[2] ?? program.name() }
+);

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@notation/cli",
-  "version": "0.11.1",
+  "version": "0.14.0",
   "files": [
     "dist",
     "templates"
@@ -13,10 +13,10 @@
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",
     "esbuild": "^0.25.0",
-    "glob": "^11.0.1",
-    "@notation/core": "0.11.1",
-    "@notation/dashboard": "0.11.1",
-    "@notation/esbuild-plugins": "0.11.1"
+    "glob": "^13.0.6",
+    "@notation/core": "0.14.0",
+    "@notation/dashboard": "0.14.0",
+    "@notation/esbuild-plugins": "0.14.0"
   },
   "devDependencies": {
     "@types/which-pm-runs": "^1.0.2"