@notation/cli 0.4.2 → 0.5.0

package/dist/index.js

@@ -4,8 +4,7 @@
 import { program } from "commander";
 
 // src/compile.ts
-import fs from "fs";
-import * as fflate from "fflate";
+import chokidar from "chokidar";
 import { glob } from "glob";
 import { log } from "console";
 import esbuild from "esbuild";
@@ -14,15 +13,26 @@ import {
   functionRuntimePlugin
 } from "@notation/esbuild-plugins";
 import { filePaths } from "@notation/core";
-async function compile(entryPoint) {
-  await compileInfra(entryPoint);
+async function compile(entryPoint, watch2 = false) {
+  log(`${watch2 ? "Watching" : "Compiling"} infrastructure`, entryPoint);
+  await compileInfra(entryPoint, watch2);
+  log(`${watch2 ? "Watching" : "Compiling"} functions`);
   const fnEntryPoints = await glob("**/*.fn.ts");
-  await compileFns(fnEntryPoints);
-  await zipFns(fnEntryPoints);
+  let disposeFnCompiler = await compileFns(fnEntryPoints, watch2);
+  if (!watch2)
+    return;
+  chokidar.watch("**/*.fn.ts", {
+    ignored: /node_modules/,
+    persistent: true
+  }).on("all", async () => {
+    if (disposeFnCompiler)
+      disposeFnCompiler();
+    const fnEntryPoints2 = await glob("**/*.fn.ts");
+    disposeFnCompiler = await compileFns(fnEntryPoints2, watch2);
+  });
 }
-async function compileInfra(entryPoint) {
-  log("Compiling infrastructure", entryPoint);
-  await esbuild.build({
+async function compileInfra(entryPoint, watch2 = false) {
+  const context = await esbuild.context({
     entryPoints: [entryPoint],
     plugins: [functionInfraPlugin()],
     outdir: "dist/infra",
@@ -34,11 +44,16 @@ async function compileInfra(entryPoint) {
     treeShaking: true,
     packages: "external"
   });
+  if (watch2) {
+    await context.watch();
+  } else {
+    await context.rebuild();
+    context.dispose();
+  }
 }
-async function compileFns(entryPoints) {
-  log("Compiling functions");
+async function compileFns(entryPoints, watch2 = false) {
   for (const entryPoint of entryPoints) {
-    await esbuild.build({
+    const context = await esbuild.context({
       entryPoints: [entryPoint],
       plugins: [functionRuntimePlugin()],
       outfile: filePaths.dist.runtime.index(entryPoint),
@@ -48,46 +63,37 @@ async function compileFns(entryPoints) {
       platform: "node",
       treeShaking: true
     });
+    if (watch2) {
+      await context.watch();
+      return () => context.dispose();
+    } else {
+      await context.rebuild();
+      context.dispose();
+    }
   }
 }
-async function zipFns(entryPoints) {
-  log("Compiling deployable packages");
-  for (const entryPoint of entryPoints) {
-    const inputFilePath = filePaths.dist.runtime.index(entryPoint);
-    const inputFile = fs.readFileSync(inputFilePath);
-    const zipFilePath = `${inputFilePath}.zip`;
-    const archive = fflate.zipSync({ "index.mjs": inputFile }, { level: 9 });
-    fs.writeFileSync(zipFilePath, archive);
-  }
-}
-
-// src/utils.ts
-import path from "path";
-import { getResources, getResourceGroups, filePaths as filePaths2 } from "@notation/core";
-async function getResourceGraph(entryPoint) {
-  const outFilePath = filePaths2.dist.infra(entryPoint);
-  await import(path.join(process.cwd(), outFilePath));
-  const resourceGroups = getResourceGroups();
-  const resources = getResources();
-  return { resourceGroups, resources };
-}
 
 // src/deploy.ts
+import { deployApp } from "@notation/core";
 async function deploy(entryPoint) {
   await compile(entryPoint);
+  console.log(`Deploying ${entryPoint}`);
   await deployApp(entryPoint);
 }
-async function deployApp(entryPoint) {
-  console.log(`Deploying ${entryPoint}`);
-  const graph = await getResourceGraph(entryPoint);
-  for (const resource of graph.resources) {
-    await resource.runDeploy();
-    console.log(`Deployed ${resource.type} ${resource.id}`);
-  }
+
+// src/destroy.ts
+import { destroyApp } from "@notation/core";
+async function destroy(entryPoint) {
+  await compile(entryPoint);
+  await destroyApp(entryPoint);
 }
 
 // src/visualise.ts
-import { createMermaidFlowChart, createMermaidLiveUrl } from "@notation/core";
+import {
+  createMermaidFlowChart,
+  createMermaidLiveUrl,
+  getResourceGraph
+} from "@notation/core";
 import { log as log2 } from "console";
 async function visualise(entryPoint) {
   await compileInfra(entryPoint);
@@ -102,30 +108,72 @@ async function generateGraph(entryPoint) {
   log2(chartUrl);
 }
 
+// src/watch.ts
+import chokidar2 from "chokidar";
+import { deployApp as deployApp2 } from "@notation/core";
+var dotFilesRe = /(^|[\/\\])\../;
+async function watch(entryPoint) {
+  await compile(entryPoint, true);
+  const watcher = chokidar2.watch("dist", {
+    ignored: dotFilesRe,
+    persistent: true
+  });
+  watcher.on("all", debounceDeploy);
+  let isDeploying = false;
+  let deployQueued = false;
+  let timeoutId;
+  const debounceTime = 500;
+  function debounceDeploy() {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      triggerDeploy();
+    }, debounceTime);
+  }
+  function triggerDeploy() {
+    if (isDeploying) {
+      deployQueued = true;
+      return;
+    }
+    isDeploying = true;
+    deployApp2(entryPoint, false).then(() => {
+      isDeploying = false;
+      if (deployQueued) {
+        deployQueued = false;
+        triggerDeploy();
+      }
+    }).catch((err) => {
+      console.error(err);
+      isDeploying = false;
+    });
+  }
+}
+
 // src/scaffold.ts
-import path2 from "node:path";
+import path from "node:path";
 import fse from "fs-extra";
 import { execSync } from "node:child_process";
 import whichPmRuns from "which-pm-runs";
-var dirname = path2.dirname(new URL(import.meta.url).pathname);
+var dirname = path.dirname(new URL(import.meta.url).pathname);
 var packageManager = whichPmRuns()?.name || "npm";
 var packageManagerInstallCommand = getPmInstallCommand(packageManager);
 async function scaffoldApp(appName) {
   const cwd = process.cwd();
-  const appDir = path2.join(cwd, appName);
+  const appDir = path.join(cwd, appName);
   await fse.ensureDir(appDir);
   const children = await fse.readdir(appDir);
   if (children.length) {
     console.error(
-      `Directory ${path2.relative(process.cwd(), appDir)} is not empty`
+      `Directory ${path.relative(process.cwd(), appDir)} is not empty`
     );
     return;
   }
   console.log(`
 Creating app from template...`);
-  const templateDir = path2.join(dirname, "../templates/starter");
+  const templateDir = path.join(dirname, "../templates/starter");
   await fse.copy(templateDir, appDir);
-  const packageJsonPath = path2.join(appDir, "package.json");
+  const packageJsonPath = path.join(appDir, "package.json");
   const packageJsonContent = await fse.readFile(packageJsonPath, "utf8");
   const packageJson = JSON.parse(packageJsonContent);
   packageJson.name = appName;
@@ -180,4 +228,10 @@ program.command("viz").argument("<entryPoint>", "entryPoint").description("Visua
 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").action(async (entryPoint) => {
+  await destroy(entryPoint);
+});
+program.command("watch").argument("<entryPoint>", "entryPoint").description("Watch Notation App").action(async (entryPoint) => {
+  await watch(entryPoint);
+});
 program.parse(process.argv);

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@notation/cli",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "files": [
     "dist",
     "templates"
@@ -10,16 +10,18 @@
     "notation": "dist/index.js"
   },
   "dependencies": {
-    "@types/fs-extra": "^11.0.4",
-    "@types/which-pm-runs": "^1.0.2",
+    "chokidar": "^3.5.3",
     "commander": "^11.0.0",
     "esbuild": "^0.19.3",
-    "fflate": "0.8.1",
     "fs-extra": "^11.1.1",
     "glob": "^10.3.10",
     "which-pm-runs": "^1.1.0",
-    "@notation/core": "0.3.1",
-    "@notation/esbuild-plugins": "0.3.1"
+    "@notation/core": "0.4.0",
+    "@notation/esbuild-plugins": "0.3.2"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/which-pm-runs": "^1.0.2"
   },
   "scripts": {
     "build": "tsup",

package/templates/starter/package.json

@@ -2,6 +2,8 @@
   "private": true,
   "name": "notation-starter",
   "scripts": {
-    "viz": "notation viz src/api.ts"
+    "viz": "notation viz src/api.ts",
+    "deploy": "notation deploy src/api.ts",
+    "destroy": "notation destroy src/api.ts"
   }
 }