@notation/cli 0.4.2 → 0.6.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,18 +13,29 @@ import {
   functionRuntimePlugin
 } from "@notation/esbuild-plugins";
 import { filePaths } from "@notation/core";
-async function compile(entryPoint) {
-  await compileInfra(entryPoint);
-  const fnEntryPoints = await glob("**/*.fn.ts");
-  await compileFns(fnEntryPoints);
-  await zipFns(fnEntryPoints);
+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("runtime/**/*.fn.ts");
+  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("runtime/**/*.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",
+    outdir: "dist",
     outbase: ".",
     outExtension: { ".js": ".mjs" },
     bundle: true,
@@ -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
     });
-  }
-}
-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);
+    if (watch2) {
+      await context.watch();
+      return () => context.dispose();
+    } else {
+      await context.rebuild();
+      context.dispose();
+    }
   }
 }
 
-// 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,82 +108,66 @@ async function generateGraph(entryPoint) {
   log2(chartUrl);
 }
 
-// src/scaffold.ts
-import path2 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 packageManager = whichPmRuns()?.name || "npm";
-var packageManagerInstallCommand = getPmInstallCommand(packageManager);
-async function scaffoldApp(appName) {
-  const cwd = process.cwd();
-  const appDir = path2.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`
-    );
-    return;
-  }
-  console.log(`
-Creating app from template...`);
-  const templateDir = path2.join(dirname, "../templates/starter");
-  await fse.copy(templateDir, appDir);
-  const packageJsonPath = path2.join(appDir, "package.json");
-  const packageJsonContent = await fse.readFile(packageJsonPath, "utf8");
-  const packageJson = JSON.parse(packageJsonContent);
-  packageJson.name = appName;
-  const updatedPackageJson = JSON.stringify(packageJson, null, 2);
-  await fse.writeFile(packageJsonPath, updatedPackageJson, {
-    encoding: "utf8"
-  });
-  console.log(`Installing dependencies with ${packageManager}...`);
-  execSync(`${packageManagerInstallCommand} @notation/cli @notation/aws`, {
-    cwd: appDir,
-    stdio: "inherit"
+// 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
   });
-  console.log("\nApp ready! To get started run:\n");
-  console.log(`\u279C cd ${appName}`);
-  console.log(`\u279C ${getPmRunCommand(packageManager)} viz`);
-}
-function getPmInstallCommand(pm) {
-  switch (pm) {
-    case "yarn":
-      return "yarn add";
-    case "pnpm":
-      return "pnpm add";
-    case "bun":
-      return "bun add";
-    default:
-      return "npm install";
+  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 getPmRunCommand(pm) {
-  switch (pm) {
-    case "yarn":
-      return "yarn";
-    case "pnpm":
-      return "pnpm";
-    case "bun":
-      return "bun";
-    default:
-      return "npm run";
+  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/index.ts
-program.command("create").argument("[appName]", "app name", "notation-starter").description("Create Notation App").action(async (appName) => {
-  await scaffoldApp(appName);
-});
+import { startDashboardServer } from "@notation/dashboard";
 program.command("compile").argument("<entryPoint>", "entryPoint").description("Compile Notation App").action(async (entryPoint) => {
   await compile(entryPoint);
 });
-program.command("viz").argument("<entryPoint>", "entryPoint").description("Visualise Notation App").action(async (entryPoint) => {
-  await visualise(entryPoint);
+program.command("dashboard").description("Start Notation Dashboard").action(async () => {
+  await startDashboardServer();
 });
 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("viz").argument("<entryPoint>", "entryPoint").description("Visualise Notation App").action(async (entryPoint) => {
+  await visualise(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.6.0",
   "files": [
     "dist",
     "templates"
@@ -10,19 +10,19 @@
     "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.1",
+    "@notation/esbuild-plugins": "0.4.0",
+    "@notation/dashboard": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/which-pm-runs": "^1.0.2"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsup --clean",
     "dev": "npm run build -- --watch"
   }
 }

package/templates/starter/package.json

@@ -1,7 +0,0 @@
-{
-  "private": true,
-  "name": "notation-starter",
-  "scripts": {
-    "viz": "notation viz src/api.ts"
-  }
-}

package/templates/starter/src/api.ts

@@ -1,8 +0,0 @@
-import { api, router } from "@notation/aws/api-gateway";
-import { getTodos, getTodoCount } from "./todos/todos.fn";
-
-const todoApi = api({ name: "todo-api" });
-const todoRouter = router(todoApi);
-
-todoRouter.get("/todos", getTodos);
-todoRouter.get("/todos/count", getTodoCount);

package/templates/starter/src/todos/todos.fn.ts

@@ -1,19 +0,0 @@
-import type { LambdaConfig } from "@notation/aws/lambda.fn";
-import { handle, json } from "@notation/aws/lambda.fn";
-import { api } from "./utils";
-
-const todos = await api.get<any[]>("/todos");
-
-export const getTodos = handle.apiRequest(() => {
-  return json(todos);
-});
-
-export const getTodoCount = handle.apiRequest(() => {
-  return json(todos.length);
-});
-
-export const config: LambdaConfig = {
-  service: "aws/lambda",
-  timeout: 5,
-  memory: 64,
-};

package/templates/starter/src/todos/utils.ts

@@ -1,6 +0,0 @@
-export const api = {
-  get: async <T = any>(path: string) => {
-    const res = await fetch(`https://jsonplaceholder.typicode.com${path}`);
-    return res.json() as Promise<T>;
-  },
-};

package/templates/starter/tsconfig.json

@@ -1,27 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "display": "Default",
-  "compilerOptions": {
-    "lib": ["esnext"],
-    "module": "esnext",
-    "target": "esnext",
-
-    "moduleResolution": "bundler",
-    "noEmit": true,
-
-    "composite": false,
-    "declaration": true,
-    "declarationMap": true,
-    "forceConsistentCasingInFileNames": true,
-    "inlineSources": false,
-    "isolatedModules": true,
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "preserveWatchOutput": true,
-    "skipDefaultLibCheck": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "strictNullChecks": true
-  },
-  "exclude": ["node_modules"]
-}