@botonic/nx-plugin 2.31.0 → 2.32.0-alpha.0

package/src/generators/bot-app/generator.js

@@ -28,300 +28,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var generator_exports = {};
 __export(generator_exports, {
-  default: () => generator_default
+  default: () => import_generator_impl.default
 });
 module.exports = __toCommonJS(generator_exports);
-var import_devkit = require("@nx/devkit");
-var import_child_process = require("child_process");
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-const MODULE_DIR = __dirname;
-function getLilaraVersion(options) {
-  const version = options.lilaraVersion;
-  if (version && version !== "latest") {
-    return version.replace(/^[\^~]/, "");
-  }
-  const jsonPath = path.join(MODULE_DIR, "lilara-version.json");
-  try {
-    if (fs.existsSync(jsonPath)) {
-      const data = JSON.parse(fs.readFileSync(jsonPath, "utf-8"));
-      if (data.version && typeof data.version === "string") {
-        return data.version.replace(/^[\^~]/, "");
-      }
-    }
-  } catch {
-  }
-  try {
-    const tag = (0, import_child_process.execSync)('git describe --tags --match "lilara-v*" --abbrev=0', {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const v = tag.replace(/^lilara-v/, "");
-    if (v) return v;
-  } catch {
-  }
-  return "latest";
-}
-function getBotonicVersion(options) {
-  const version = options.botonicVersion;
-  if (version && version !== "{{WORKSPACE_VERSION}}" && version !== "latest") {
-    return version.replace(/^[\^~]/, "");
-  }
-  try {
-    const packageJsonPath = path.resolve(
-      MODULE_DIR,
-      "..",
-      "..",
-      "..",
-      "package.json"
-    );
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-    return packageJson.version || "latest";
-  } catch (error) {
-    console.warn("Could not read plugin version, using latest:", error);
-    return "latest";
-  }
-}
-function normalizeOptions(tree, options) {
-  let appName = options.name;
-  let directory = options.directory;
-  if (options.name.includes("/")) {
-    const parts = options.name.split("/");
-    appName = parts.pop();
-    if (!directory) {
-      directory = parts.join("/");
-    }
-  }
-  const name = (0, import_devkit.names)(appName).fileName;
-  if (!name) {
-    throw new Error(`Failed to normalize app name: ${appName}`);
-  }
-  let projectDirectory;
-  if (directory) {
-    const directoryName = (0, import_devkit.names)(directory).fileName;
-    if (!directoryName) {
-      throw new Error(`Failed to normalize directory name: ${directory}`);
-    }
-    projectDirectory = `${directoryName}/${name}`;
-  } else {
-    projectDirectory = name;
-  }
-  if (!projectDirectory) {
-    throw new Error(
-      `Failed to determine project directory for app name: ${appName}`
-    );
-  }
-  const projectName = projectDirectory.replace(new RegExp("/", "g"), "-");
-  const projectRoot = `${(0, import_devkit.getWorkspaceLayout)(tree).appsDir}/${projectDirectory}`;
-  return {
-    ...options,
-    name: appName,
-    // Use the parsed app name
-    directory,
-    // Use the parsed directory
-    projectName,
-    projectRoot,
-    projectDirectory
-  };
-}
-function createProjectConfiguration(tree, options) {
-  const projectConfig = {
-    name: options.projectName,
-    root: options.projectRoot,
-    sourceRoot: `${options.projectRoot}/src`,
-    projectType: "application",
-    tags: ["type:app", "botonic:bot-app"]
-    // Note: targets are now inferred by the @botonic/nx-plugin based on the 'botonic:bot-app' tag
-    // and the presence of configuration files (vite.config.ts, bot-config.ts, etc.)
-  };
-  (0, import_devkit.addProjectConfiguration)(tree, options.projectName, projectConfig);
-}
-function createPackageJson(tree, options, botonicVersion, lilaraVersion) {
-  const packageJson = {
-    name: options.projectName,
-    version: "1.0.0",
-    type: "module",
-    private: true,
-    description: `Botonic bot application: ${options.projectName}`,
-    main: "dist/src/index.js",
-    scripts: {},
-    dependencies: {
-      "@botonic/core": botonicVersion,
-      "@botonic/plugin-ai-agents": botonicVersion,
-      "@botonic/plugin-flow-builder": botonicVersion,
-      "@botonic/plugin-hubtype-analytics": botonicVersion,
-      "@botonic/shared": botonicVersion,
-      "@botonic/webchat-core": botonicVersion,
-      "@botonic/webchat-react": botonicVersion,
-      "@botonic/webviews": botonicVersion,
-      "@lilara/foundations": lilaraVersion,
-      "@lilara/ui-web": lilaraVersion,
-      "@lilara/ui-web-react": lilaraVersion,
-      react: "18.3.1",
-      "react-dom": "18.3.1",
-      zod: "^4.4.3"
-    },
-    devDependencies: {
-      "@nx/vite": "21.6.11",
-      "@types/node": "22.13.0",
-      "@types/react": "18.3.1",
-      "@types/react-dom": "18.3.0",
-      "@vitejs/plugin-react": "^4.2.0",
-      "@vitejs/plugin-react-swc": "^3.5.0",
-      typescript: "5.7.3",
-      vite: "7.1.9",
-      vitest: "4.1.1"
-    }
-  };
-  (0, import_devkit.writeJson)(tree, `${options.projectRoot}/package.json`, packageJson);
-}
-function createTsConfigs(tree, options) {
-  const tsconfig = {
-    compilerOptions: {
-      jsx: "react-jsx",
-      allowJs: false,
-      esModuleInterop: true,
-      allowSyntheticDefaultImports: true,
-      resolveJsonModule: true,
-      strict: true,
-      types: ["vite/client", "vitest"]
-    },
-    files: [],
-    include: ["src/**/*.ts", "src/**/*.tsx"],
-    references: [
-      { path: "./tsconfig.app.json" },
-      { path: "./tsconfig.spec.json" }
-    ],
-    extends: "../../tsconfig.base.json"
-  };
-  const tsconfigApp = {
-    extends: "./tsconfig.json",
-    compilerOptions: {
-      outDir: "./dist/out-tsc",
-      types: ["node", "vite/client"],
-      composite: true,
-      noEmit: false,
-      declaration: true
-    },
-    files: [
-      "../../node_modules/@nx/react/typings/cssmodule.d.ts",
-      "../../node_modules/@nx/react/typings/image.d.ts"
-    ],
-    exclude: [
-      "jest.config.ts",
-      "src/**/*.spec.ts",
-      "src/**/*.test.ts",
-      "src/**/*.spec.tsx",
-      "src/**/*.test.tsx",
-      "src/**/*.spec.js",
-      "src/**/*.test.js",
-      "src/**/*.spec.jsx",
-      "src/**/*.test.jsx"
-    ],
-    include: ["src/**/*.js", "src/**/*.jsx", "src/**/*.ts", "src/**/*.tsx"]
-  };
-  const tsconfigSpec = {
-    extends: "./tsconfig.json",
-    compilerOptions: {
-      outDir: "./dist/out-tsc",
-      module: "commonjs",
-      types: ["vitest/globals", "vitest/importMeta", "vite/client", "node"],
-      composite: true,
-      noEmit: false,
-      declaration: true
-    },
-    include: [
-      "vite.config.ts",
-      "vitest.config.ts",
-      "src/**/*.test.ts",
-      "src/**/*.spec.ts",
-      "src/**/*.test.tsx",
-      "src/**/*.spec.tsx",
-      "src/**/*.test.js",
-      "src/**/*.spec.js",
-      "src/**/*.test.jsx",
-      "src/**/*.spec.jsx",
-      "src/**/*.d.ts"
-    ]
-  };
-  (0, import_devkit.writeJson)(tree, `${options.projectRoot}/tsconfig.json`, tsconfig);
-  (0, import_devkit.writeJson)(tree, `${options.projectRoot}/tsconfig.app.json`, tsconfigApp);
-  (0, import_devkit.writeJson)(tree, `${options.projectRoot}/tsconfig.spec.json`, tsconfigSpec);
-}
-function addBotonicDependencies(tree, botonicVersion) {
-  return (0, import_devkit.addDependenciesToPackageJson)(
-    tree,
-    // dependencies
-    {
-      react: "18.3.1",
-      "react-dom": "18.3.1"
-    },
-    // devDependencies
-    {
-      "@nx/vite": "21.6.11",
-      "@types/node": "22.13.0",
-      "@types/react": "18.3.1",
-      "@types/react-dom": "18.3.0",
-      "@vitejs/plugin-react": "4.2.0",
-      "@vitejs/plugin-react-swc": "3.5.0",
-      typescript: "5.7.3",
-      vite: "7.1.9",
-      vitest: "4.1.1"
-    }
-  );
-}
-function addBotonicFiles(tree, options, botonicVersion) {
-  const templateOptions = {
-    ...options,
-    ...(0, import_devkit.names)(options.name),
-    botonicVersion
-  };
-  (0, import_devkit.generateFiles)(
-    tree,
-    (0, import_devkit.joinPathFragments)(MODULE_DIR, "files"),
-    options.projectRoot,
-    templateOptions
-  );
-}
-async function generator_default(tree, options) {
-  const botonicVersion = getBotonicVersion(options);
-  const lilaraVersion = getLilaraVersion(options);
-  const tasks = [];
-  console.log(`\u{1F916} Using Botonic version: ${botonicVersion}`);
-  console.log(`\u{1F3A8} Using Lilara version: ${lilaraVersion}`);
-  console.log(`\u{1F50D} Creating project using programmatic configuration...`);
-  const normalizedOptions = normalizeOptions(tree, options);
-  console.log(`\u{1F50D} Normalized options:`, {
-    projectName: normalizedOptions.projectName,
-    projectRoot: normalizedOptions.projectRoot,
-    projectDirectory: normalizedOptions.projectDirectory
-  });
-  createProjectConfiguration(tree, normalizedOptions);
-  createPackageJson(tree, normalizedOptions, botonicVersion, lilaraVersion);
-  createTsConfigs(tree, normalizedOptions);
-  const depsTask = addBotonicDependencies(tree, botonicVersion);
-  tasks.push(depsTask);
-  tasks.push(() => (0, import_devkit.installPackagesTask)(tree));
-  tasks.push(
-    () => (0, import_devkit.installPackagesTask)(
-      tree,
-      true,
-      `${normalizedOptions.projectRoot}/src/server/lambda/`
-    )
-  );
-  addBotonicFiles(tree, normalizedOptions, botonicVersion);
-  await (0, import_devkit.formatFiles)(tree);
-  tasks.push(() => {
-    console.log(
-      `
-\u{1F389} Successfully created Botonic bot app: ${normalizedOptions.projectName}`
-    );
-    console.log(`\u{1F4C1} Project location: ${normalizedOptions.projectRoot}`);
-    console.log(`
-\u{1F4CB} Next step:`);
-    console.log(`   npx nx run ${normalizedOptions.projectName}:serve`);
-    console.log(`
-\u{1F680} Happy bot building!`);
-  });
-  return (0, import_devkit.runTasksInSerial)(...tasks);
-}
+var import_generator_impl = __toESM(require("./generator-impl"));

package/src/generators/custom-message/generator-impl.d.ts

@@ -0,0 +1,4 @@
+import { Tree } from '@nx/devkit';
+import type { CustomMessageGeneratorSchema } from './schema';
+export default function (tree: Tree, options: CustomMessageGeneratorSchema): Promise<void>;
+export { CustomMessageGeneratorSchema };

package/src/generators/custom-message/generator-impl.js

@@ -0,0 +1,235 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var generator_impl_exports = {};
+__export(generator_impl_exports, {
+  default: () => generator_impl_default
+});
+module.exports = __toCommonJS(generator_impl_exports);
+var import_devkit = require("@nx/devkit");
+var import_bot_app_utils = require("../shared/bot-app-utils");
+const MODULE_DIR = __dirname;
+function normalizeOptions(tree, options) {
+  const { projectRoot, sourceRoot } = (0, import_bot_app_utils.validateBotAppProject)(
+    tree,
+    options.project
+  );
+  const paths = (0, import_bot_app_utils.resolveStandardPaths)(sourceRoot);
+  const name = (0, import_devkit.names)(options.name);
+  const fileName = name.fileName;
+  const className = name.className;
+  const propertyName = name.propertyName;
+  const constantName = name.constantName.toUpperCase();
+  const customMessagesPath = options.directory ? `${sourceRoot}/client/custom-messages/${options.directory}` : `${sourceRoot}/client/custom-messages`;
+  return {
+    ...options,
+    projectName: options.project,
+    projectRoot,
+    fileName,
+    className,
+    propertyName,
+    constantName,
+    customMessagesPath,
+    constantsPath: paths.constantsPath,
+    actionsPath: paths.actionsPath,
+    routesPath: paths.routesPath
+  };
+}
+function addFilesToProject(tree, options) {
+  const name = (0, import_devkit.names)(options.name);
+  const templateOptions = {
+    ...options,
+    ...name,
+    name: name.fileName
+    // __name__ in filenames must be kebab-case
+  };
+  (0, import_devkit.generateFiles)(
+    tree,
+    (0, import_devkit.joinPathFragments)(MODULE_DIR, "files"),
+    options.customMessagesPath,
+    templateOptions
+  );
+  if (options.skipTests) {
+    const testFilePath = `${options.customMessagesPath}/${options.fileName}.spec.tsx`;
+    if (tree.exists(testFilePath)) {
+      tree.delete(testFilePath);
+    }
+  }
+  if (options.skipAction) {
+    const actionPath = `${options.customMessagesPath}/${options.fileName}-output.ts`;
+    if (tree.exists(actionPath)) {
+      tree.delete(actionPath);
+    }
+  } else {
+    const sourceActionPath = `${options.customMessagesPath}/${options.fileName}-output.ts`;
+    const targetActionPath = `${options.actionsPath}/${options.fileName}.ts`;
+    if (tree.exists(sourceActionPath)) {
+      const content = tree.read(sourceActionPath, "utf-8");
+      tree.write(targetActionPath, content);
+      tree.delete(sourceActionPath);
+    }
+  }
+}
+function updateCustomMessagesIndex(tree, options) {
+  const indexPath = `${options.customMessagesPath}/index.ts`;
+  if (!tree.exists(indexPath)) {
+    tree.write(
+      indexPath,
+      `import { CUSTOM_MESSAGE_TYPES } from '../../shared/constants'
+
+export const customMessages = {
+  [CUSTOM_MESSAGE_TYPES.${options.constantName}]: ${options.className},
+}
+`
+    );
+    return;
+  }
+  const content = tree.read(indexPath, "utf-8");
+  const lines = content.split("\n");
+  const importStatement = `import { ${options.className} } from './${options.directory ? options.directory + "/" : ""}${options.fileName}'`;
+  let importInsertIndex = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].startsWith("import")) {
+      importInsertIndex = i + 1;
+    } else if (lines[i].trim() === "" && importInsertIndex > 0) {
+      break;
+    }
+  }
+  lines.splice(importInsertIndex, 0, importStatement);
+  const exportLineIndex = lines.findIndex(
+    (line) => line.includes("export const customMessages")
+  );
+  if (exportLineIndex !== -1) {
+    let braceIndex = exportLineIndex;
+    while (braceIndex < lines.length && !lines[braceIndex].includes("{")) {
+      braceIndex++;
+    }
+    if (braceIndex < lines.length) {
+      const braceLine = lines[braceIndex];
+      if (braceLine.trim() === "{" || braceLine.includes("{}")) {
+        const newEntry = `  [CUSTOM_MESSAGE_TYPES.${options.constantName}]: ${options.className},`;
+        if (braceLine.includes("{}")) {
+          lines[braceIndex] = braceLine.replace("{}", `{
+${newEntry}
+}`);
+        } else {
+          lines.splice(braceIndex + 1, 0, newEntry);
+        }
+      } else {
+        let closingBraceIndex = braceIndex;
+        let braceCount = 0;
+        for (let i = braceIndex; i < lines.length; i++) {
+          for (const char of lines[i]) {
+            if (char === "{") braceCount++;
+            if (char === "}") braceCount--;
+          }
+          if (braceCount === 0) {
+            closingBraceIndex = i;
+            break;
+          }
+        }
+        const newEntry = `  [CUSTOM_MESSAGE_TYPES.${options.constantName}]: ${options.className},`;
+        lines.splice(closingBraceIndex, 0, newEntry);
+      }
+    }
+  }
+  tree.write(indexPath, lines.join("\n"));
+}
+function updateConstantsFile(tree, options) {
+  if (!tree.exists(options.constantsPath)) {
+    tree.write(
+      options.constantsPath,
+      `export const CUSTOM_MESSAGE_TYPES = {
+  ${options.constantName}: '${options.fileName}',
+} as const
+
+export const WEBVIEWS = {
+  // Add your webviews here
+} as const
+
+export const PAYLOADS = {
+  // Add your payloads here
+} as const
+`
+    );
+    return;
+  }
+  (0, import_bot_app_utils.addConstEntry)(
+    tree,
+    options.constantsPath,
+    "CUSTOM_MESSAGE_TYPES",
+    options.constantName,
+    options.fileName
+  );
+}
+function updateActionsIndex(tree, options) {
+  if (options.skipAction) {
+    return;
+  }
+  (0, import_bot_app_utils.addExportToIndex)(
+    tree,
+    `${options.actionsPath}/index.ts`,
+    `export * from './${options.fileName}'`
+  );
+}
+function updateRoutes(tree, options) {
+  if (options.skipAction) {
+    return;
+  }
+  const actionImport = `${options.propertyName}Output`;
+  (0, import_bot_app_utils.addActionImportToRoutes)(tree, options.routesPath, actionImport);
+  (0, import_bot_app_utils.insertRouteBeforeFlowBuilder)(tree, options.routesPath, [
+    `    {`,
+    `      text: '${options.fileName}',`,
+    `      action: async () => await ${actionImport}(botonicContext),`,
+    `    },`
+  ]);
+}
+async function generator_impl_default(tree, options) {
+  console.log(`Creating custom message: ${options.name}`);
+  const normalizedOptions = normalizeOptions(tree, options);
+  console.log(`Project: ${normalizedOptions.projectName}`);
+  console.log(`Location: ${normalizedOptions.customMessagesPath}`);
+  addFilesToProject(tree, normalizedOptions);
+  updateConstantsFile(tree, normalizedOptions);
+  updateCustomMessagesIndex(tree, normalizedOptions);
+  updateActionsIndex(tree, normalizedOptions);
+  updateRoutes(tree, normalizedOptions);
+  await (0, import_devkit.formatFiles)(tree);
+  console.log(
+    `
+Successfully created custom message: ${normalizedOptions.className}`
+  );
+  console.log(`Next steps:`);
+  console.log(
+    `  1. Customize the component in: ${normalizedOptions.customMessagesPath}/${normalizedOptions.fileName}.tsx`
+  );
+  if (!options.skipAction) {
+    console.log(
+      `  2. Update the action in: ${normalizedOptions.actionsPath}/${normalizedOptions.fileName}.ts`
+    );
+    console.log(
+      `  3. Test by typing '${normalizedOptions.fileName}' in the webchat`
+    );
+  }
+  if (!options.skipTests) {
+    console.log(
+      `  4. Update the tests in: ${normalizedOptions.customMessagesPath}/${normalizedOptions.fileName}.spec.tsx`
+    );
+  }
+}

package/src/generators/custom-message/generator.d.ts

@@ -1,4 +1,3 @@
-import { Tree } from '@nx/devkit';
+import type { Tree } from '@nx/devkit';
 import type { CustomMessageGeneratorSchema } from './schema';
-export default function (tree: Tree, options: CustomMessageGeneratorSchema): Promise<void>;
-export { CustomMessageGeneratorSchema };
+export default function (tree: Tree, options: CustomMessageGeneratorSchema): Promise<void | import("@nx/devkit").GeneratorCallback>;