cognite-create 0.2.31 → 0.2.33

package/bin/index.js

@@ -6,6 +6,8 @@ const { spawn } = require("node:child_process");
 const fs = require("node:fs/promises");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const path = require("node:path");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const readline = require("node:readline");
 
 const REQUIRED_DEPENDENCIES = [
   { name: "@tanstack/react-query", version: "^5.90.2" },
@@ -17,23 +19,63 @@ const REQUIRED_DEPENDENCIES = [
   { name: "clsx", version: "^2.1.1" },
 ];
 
+const REQUIRED_DEV_DEPENDENCIES = [
+  { name: "tailwindcss", version: "^4.0.0" },
+  { name: "@tailwindcss/vite", version: "^4.0.0" },
+  { name: "@types/node", version: "^22.10.2" },
+];
+
+function promptForInput(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
 async function main() {
   const args = process.argv.slice(2);
+  let projectDir;
+  let additionalArgs = [];
 
   if (args.length === 0 || args[0].startsWith("-")) {
-    console.error(
-      "Usage: cognite-create <project-name> [create-next-app options]"
-    );
-    process.exit(1);
+    // No project name provided, prompt for one
+    projectDir = await promptForInput("Project name: ");
+
+    if (!projectDir) {
+      console.error("Error: Project name is required");
+      process.exit(1);
+    }
+
+    // Keep any flags that were provided
+    additionalArgs = args;
+  } else {
+    // First arg is the project name
+    projectDir = args[0];
+    // Rest are additional args
+    additionalArgs = args.slice(1);
   }
 
-  const projectDir = args[0];
-  const createArgs = ["create-next-app@latest", ...args];
-  await runCreateNextApp(createArgs);
+  // Add default template if not specified
+  const hasTemplate = additionalArgs.some(
+    (arg) => arg === "--template" || arg === "-t"
+  );
+  if (!hasTemplate) {
+    additionalArgs.push("--template", "react-ts");
+  }
+
+  const createArgs = ["create-vite@latest", projectDir, ...additionalArgs];
+  await runCreateVite(createArgs);
   await addCogniteTemplates(projectDir);
 }
 
-function runCreateNextApp(cliArgs) {
+function runCreateVite(cliArgs) {
   const command = process.platform === "win32" ? "npx.cmd" : "npx";
 
   return new Promise((resolve, reject) => {
@@ -42,7 +84,7 @@ function runCreateNextApp(cliArgs) {
     child.on("error", reject);
     child.on("close", (code) => {
       if (code !== 0) {
-        const error = new Error(`create-next-app exited with code ${code}`);
+        const error = new Error(`create-vite exited with code ${code}`);
         error.exitCode = code;
         return reject(error);
       }
@@ -62,7 +104,7 @@ async function addCogniteTemplates(projectDir) {
     if (error.code === "ENOENT") {
       throw new Error(
         `Expected to find the newly created project at "${projectDir}", but it was not found. ` +
-          "Check the create-next-app output for more details."
+          "Check the create-vite output for more details."
       );
     }
 
@@ -178,7 +220,7 @@ async function ensureDependenciesInstalled(targetRoot) {
       `\nUnable to read or parse ${path.relative(
         process.cwd(),
         packageJsonPath
-      )}. Install ${formatDependencySummary(REQUIRED_DEPENDENCIES)} manually.`
+      )}. Install dependencies manually.`
     );
     return false;
   }
@@ -193,25 +235,49 @@ async function ensureDependenciesInstalled(targetRoot) {
       )
   );
 
-  if (missingDependencies.length === 0) {
+  const missingDevDependencies = REQUIRED_DEV_DEPENDENCIES.filter(
+    (dependency) =>
+      !(
+        (packageJson.dependencies &&
+          packageJson.dependencies[dependency.name]) ||
+        (packageJson.devDependencies &&
+          packageJson.devDependencies[dependency.name])
+      )
+  );
+
+  if (missingDependencies.length === 0 && missingDevDependencies.length === 0) {
     return false;
   }
 
   const packageManager = await detectPackageManager(packageJson, targetRoot);
 
-  if (!packageManager) {
-    console.warn(
-      `\nCould not determine package manager for ${path.relative(
-        process.cwd(),
-        targetRoot
-      )}. Install ${formatDependencySummary(missingDependencies)} manually.`
+  // Install regular dependencies
+  if (missingDependencies.length > 0) {
+    const dependencySummary = formatDependencySummary(missingDependencies);
+    console.log(`\nInstalling ${dependencySummary} using ${packageManager}...`);
+    await installDependencies(
+      packageManager,
+      targetRoot,
+      missingDependencies,
+      false
     );
-    return false;
   }
 
-  const dependencySummary = formatDependencySummary(missingDependencies);
-  console.log(`\nInstalling ${dependencySummary} using ${packageManager}...`);
-  await installDependencies(packageManager, targetRoot, missingDependencies);
+  // Install dev dependencies
+  if (missingDevDependencies.length > 0) {
+    const devDependencySummary = formatDependencySummary(
+      missingDevDependencies
+    );
+    console.log(
+      `\nInstalling dev dependencies ${devDependencySummary} using ${packageManager}...`
+    );
+    await installDependencies(
+      packageManager,
+      targetRoot,
+      missingDevDependencies,
+      true
+    );
+  }
 
   return true;
 }
@@ -243,16 +309,26 @@ async function detectPackageManager(packageJson, targetRoot) {
     }
   }
 
-  return null;
+  // Default to npm if no lock file is found
+  return "npm";
 }
 
-async function installDependencies(packageManager, cwd, dependencies) {
+async function installDependencies(
+  packageManager,
+  cwd,
+  dependencies,
+  isDev = false
+) {
   const dependencySpecs = dependencies.map((dependency) =>
     dependency.version
       ? `${dependency.name}@${dependency.version}`
       : dependency.name
   );
-  const { command, args } = getInstallCommand(packageManager, dependencySpecs);
+  const { command, args } = getInstallCommand(
+    packageManager,
+    dependencySpecs,
+    isDev
+  );
 
   if (!command) {
     throw new Error(`Unsupported package manager: ${packageManager}`);
@@ -278,18 +354,31 @@ async function installDependencies(packageManager, cwd, dependencies) {
   });
 }
 
-function getInstallCommand(packageManager, dependencySpecs) {
+function getInstallCommand(packageManager, dependencySpecs, isDev = false) {
   const normalized = normalizeCommand(packageManager);
+  const devFlag = isDev ? ["-D"] : [];
 
   switch (packageManager) {
     case "npm":
-      return { command: normalized, args: ["install", ...dependencySpecs] };
+      return {
+        command: normalized,
+        args: ["install", ...devFlag, ...dependencySpecs],
+      };
     case "pnpm":
-      return { command: normalized, args: ["add", ...dependencySpecs] };
+      return {
+        command: normalized,
+        args: ["add", ...devFlag, ...dependencySpecs],
+      };
     case "yarn":
-      return { command: normalized, args: ["add", ...dependencySpecs] };
+      return {
+        command: normalized,
+        args: ["add", ...devFlag, ...dependencySpecs],
+      };
     case "bun":
-      return { command: normalized, args: ["add", ...dependencySpecs] };
+      return {
+        command: normalized,
+        args: ["add", ...devFlag, ...dependencySpecs],
+      };
     default:
       return { command: null, args: [] };
   }

package/bin/index.test.js

@@ -0,0 +1,412 @@
+import { describe, it, expect, vi } from "vitest";
+
+// Mock child_process spawn
+vi.mock("node:child_process", () => ({
+  spawn: vi.fn(),
+}));
+
+// Mock readline
+vi.mock("node:readline", () => ({
+  createInterface: vi.fn(() => ({
+    question: vi.fn(),
+    close: vi.fn(),
+  })),
+}));
+
+describe("CLI Command Tests", () => {
+  describe("Argument Parsing Logic", () => {
+    it("should use first argument as project name when provided", () => {
+      const args = ["my-project", "--template", "react-ts"];
+      let projectDir;
+      let additionalArgs = [];
+
+      if (args.length === 0 || args[0].startsWith("-")) {
+        additionalArgs = args;
+      } else {
+        projectDir = args[0];
+        additionalArgs = args.slice(1);
+      }
+
+      const createArgs = ["create-vite@latest", projectDir, ...additionalArgs];
+
+      expect(projectDir).toBe("my-project");
+      expect(additionalArgs).toEqual(["--template", "react-ts"]);
+      expect(createArgs).toEqual([
+        "create-vite@latest",
+        "my-project",
+        "--template",
+        "react-ts",
+      ]);
+    });
+
+    it("should add default react-ts template when no template is specified", () => {
+      const args = ["my-project"];
+      let projectDir;
+      let additionalArgs = [];
+
+      if (args.length === 0 || args[0].startsWith("-")) {
+        additionalArgs = args;
+      } else {
+        projectDir = args[0];
+        additionalArgs = args.slice(1);
+      }
+
+      // Add default template if not specified
+      const hasTemplate = additionalArgs.some(
+        (arg) => arg === "--template" || arg === "-t"
+      );
+      if (!hasTemplate) {
+        additionalArgs.push("--template", "react-ts");
+      }
+
+      const createArgs = ["create-vite@latest", projectDir, ...additionalArgs];
+
+      expect(projectDir).toBe("my-project");
+      expect(additionalArgs).toEqual(["--template", "react-ts"]);
+      expect(createArgs).toEqual([
+        "create-vite@latest",
+        "my-project",
+        "--template",
+        "react-ts",
+      ]);
+    });
+
+    it("should not add default template if --template is already specified", () => {
+      const args = ["my-project", "--template", "vue"];
+      let projectDir;
+      let additionalArgs = [];
+
+      if (args.length === 0 || args[0].startsWith("-")) {
+        additionalArgs = args;
+      } else {
+        projectDir = args[0];
+        additionalArgs = args.slice(1);
+      }
+
+      // Add default template if not specified
+      const hasTemplate = additionalArgs.some(
+        (arg) => arg === "--template" || arg === "-t"
+      );
+      if (!hasTemplate) {
+        additionalArgs.push("--template", "react-ts");
+      }
+
+      const createArgs = ["create-vite@latest", projectDir, ...additionalArgs];
+
+      expect(projectDir).toBe("my-project");
+      expect(additionalArgs).toEqual(["--template", "vue"]);
+      expect(createArgs).toEqual([
+        "create-vite@latest",
+        "my-project",
+        "--template",
+        "vue",
+      ]);
+    });
+
+    it("should not add default template if -t is already specified", () => {
+      const args = ["my-project", "-t", "vue-ts"];
+      let projectDir;
+      let additionalArgs = [];
+
+      if (args.length === 0 || args[0].startsWith("-")) {
+        additionalArgs = args;
+      } else {
+        projectDir = args[0];
+        additionalArgs = args.slice(1);
+      }
+
+      // Add default template if not specified
+      const hasTemplate = additionalArgs.some(
+        (arg) => arg === "--template" || arg === "-t"
+      );
+      if (!hasTemplate) {
+        additionalArgs.push("--template", "react-ts");
+      }
+
+      const createArgs = ["create-vite@latest", projectDir, ...additionalArgs];
+
+      expect(projectDir).toBe("my-project");
+      expect(additionalArgs).toEqual(["-t", "vue-ts"]);
+      expect(createArgs).toEqual([
+        "create-vite@latest",
+        "my-project",
+        "-t",
+        "vue-ts",
+      ]);
+    });
+
+    it("should handle flags-only arguments (requires prompt)", () => {
+      const args = ["--template", "react-ts"];
+      let projectDir;
+      let additionalArgs = [];
+
+      if (args.length === 0 || args[0].startsWith("-")) {
+        // Would prompt for project name
+        projectDir = undefined;
+        additionalArgs = args;
+      } else {
+        projectDir = args[0];
+        additionalArgs = args.slice(1);
+      }
+
+      expect(projectDir).toBeUndefined();
+      expect(additionalArgs).toEqual(["--template", "react-ts"]);
+    });
+
+    it("should handle empty arguments (requires prompt)", () => {
+      const args = [];
+      let projectDir;
+      let additionalArgs = [];
+
+      if (args.length === 0 || args[0]?.startsWith("-")) {
+        projectDir = undefined;
+        additionalArgs = args;
+      } else {
+        projectDir = args[0];
+        additionalArgs = args.slice(1);
+      }
+
+      expect(projectDir).toBeUndefined();
+      expect(additionalArgs).toEqual([]);
+    });
+
+    it("should properly construct create-vite command with all arguments", () => {
+      const projectDir = "test-app";
+      const additionalArgs = ["--template", "react-ts", "--force"];
+      const createArgs = ["create-vite@latest", projectDir, ...additionalArgs];
+
+      expect(createArgs).toEqual([
+        "create-vite@latest",
+        "test-app",
+        "--template",
+        "react-ts",
+        "--force",
+      ]);
+    });
+
+    it("should properly construct create-vite command with project name only", () => {
+      const projectDir = "simple-app";
+      const additionalArgs = [];
+      const createArgs = ["create-vite@latest", projectDir, ...additionalArgs];
+
+      expect(createArgs).toEqual(["create-vite@latest", "simple-app"]);
+    });
+  });
+
+  describe("Command Platform Detection", () => {
+    it("should use npx.cmd on Windows", () => {
+      const platform = "win32";
+      const command = platform === "win32" ? "npx.cmd" : "npx";
+      expect(command).toBe("npx.cmd");
+    });
+
+    it("should use npx on non-Windows platforms", () => {
+      const platform = "darwin";
+      const command = platform === "win32" ? "npx.cmd" : "npx";
+      expect(command).toBe("npx");
+    });
+  });
+
+  describe("Package Manager Detection", () => {
+    it("should detect package manager from packageManager field", () => {
+      const packageJson = { packageManager: "pnpm@8.0.0" };
+      const [name] = packageJson.packageManager.split("@");
+      expect(name).toBe("pnpm");
+    });
+
+    it("should extract package manager name correctly", () => {
+      const examples = [
+        { input: "npm@9.0.0", expected: "npm" },
+        { input: "yarn@3.0.0", expected: "yarn" },
+        { input: "pnpm@8.0.0", expected: "pnpm" },
+        { input: "bun@1.0.0", expected: "bun" },
+      ];
+
+      examples.forEach(({ input, expected }) => {
+        const [name] = input.split("@");
+        expect(name).toBe(expected);
+      });
+    });
+
+    it("should default to npm when no package manager is detected", () => {
+      // When no packageManager field exists and no lock files are found
+      // the function should default to 'npm' instead of returning null
+      const defaultPackageManager = "npm";
+      expect(defaultPackageManager).toBe("npm");
+    });
+  });
+
+  describe("Install Command Generation", () => {
+    function getInstallCommand(packageManager, dependencySpecs, isDev = false) {
+      const normalizeCommand = (cmd) => {
+        if (process.platform === "win32" && cmd !== "bun") {
+          return `${cmd}.cmd`;
+        }
+        return cmd;
+      };
+
+      const normalized = normalizeCommand(packageManager);
+      const devFlag = isDev ? ["-D"] : [];
+
+      switch (packageManager) {
+        case "npm":
+          return { command: normalized, args: ["install", ...devFlag, ...dependencySpecs] };
+        case "pnpm":
+          return { command: normalized, args: ["add", ...devFlag, ...dependencySpecs] };
+        case "yarn":
+          return { command: normalized, args: ["add", ...devFlag, ...dependencySpecs] };
+        case "bun":
+          return { command: normalized, args: ["add", ...devFlag, ...dependencySpecs] };
+        default:
+          return { command: null, args: [] };
+      }
+    }
+
+    it("should generate correct npm install command", () => {
+      const result = getInstallCommand("npm", ["package-a@1.0.0", "package-b"]);
+      expect(result.args).toEqual(["install", "package-a@1.0.0", "package-b"]);
+    });
+
+    it("should generate correct npm install command for dev dependencies", () => {
+      const result = getInstallCommand("npm", ["package-a@1.0.0", "package-b"], true);
+      expect(result.args).toEqual(["install", "-D", "package-a@1.0.0", "package-b"]);
+    });
+
+    it("should generate correct pnpm add command", () => {
+      const result = getInstallCommand("pnpm", ["package-a@1.0.0"]);
+      expect(result.args).toEqual(["add", "package-a@1.0.0"]);
+    });
+
+    it("should generate correct pnpm add command for dev dependencies", () => {
+      const result = getInstallCommand("pnpm", ["package-a@1.0.0"], true);
+      expect(result.args).toEqual(["add", "-D", "package-a@1.0.0"]);
+    });
+
+    it("should generate correct yarn add command", () => {
+      const result = getInstallCommand("yarn", ["package-a"]);
+      expect(result.args).toEqual(["add", "package-a"]);
+    });
+
+    it("should generate correct yarn add command for dev dependencies", () => {
+      const result = getInstallCommand("yarn", ["package-a"], true);
+      expect(result.args).toEqual(["add", "-D", "package-a"]);
+    });
+
+    it("should generate correct bun add command", () => {
+      const result = getInstallCommand("bun", ["package-a"]);
+      expect(result.args).toEqual(["add", "package-a"]);
+    });
+
+    it("should generate correct bun add command for dev dependencies", () => {
+      const result = getInstallCommand("bun", ["package-a"], true);
+      expect(result.args).toEqual(["add", "-D", "package-a"]);
+    });
+
+    it("should return null command for unsupported package manager", () => {
+      const result = getInstallCommand("unknown", ["package-a"]);
+      expect(result.command).toBeNull();
+      expect(result.args).toEqual([]);
+    });
+  });
+
+  describe("Dependency Formatting", () => {
+    function formatDependencySummary(dependencies) {
+      return dependencies
+        .map((dependency) =>
+          dependency.version
+            ? `${dependency.name}@${dependency.version}`
+            : dependency.name
+        )
+        .join(", ");
+    }
+
+    it("should format dependencies with versions", () => {
+      const deps = [
+        { name: "react", version: "^18.0.0" },
+        { name: "vite", version: "^5.0.0" },
+      ];
+      const result = formatDependencySummary(deps);
+      expect(result).toBe("react@^18.0.0, vite@^5.0.0");
+    });
+
+    it("should format dependencies without versions", () => {
+      const deps = [{ name: "react" }, { name: "vite" }];
+      const result = formatDependencySummary(deps);
+      expect(result).toBe("react, vite");
+    });
+
+    it("should handle mixed dependencies", () => {
+      const deps = [{ name: "react", version: "^18.0.0" }, { name: "vite" }];
+      const result = formatDependencySummary(deps);
+      expect(result).toBe("react@^18.0.0, vite");
+    });
+  });
+
+  describe("Path Normalization", () => {
+    it("should normalize Windows paths to forward slashes", () => {
+      const windowsPath = "app\\components\\Button.tsx";
+      const normalized = windowsPath.split("\\").join("/");
+      expect(normalized).toBe("app/components/Button.tsx");
+    });
+
+    it("should keep Unix paths unchanged", () => {
+      const unixPath = "app/components/Button.tsx";
+      const normalized = unixPath.split("/").join("/");
+      expect(normalized).toBe("app/components/Button.tsx");
+    });
+  });
+
+  describe("Missing Dependencies Detection", () => {
+    it("should detect missing dependencies", () => {
+      const requiredDeps = [
+        { name: "@tanstack/react-query", version: "^5.90.2" },
+        { name: "recharts", version: "^3.2.1" },
+      ];
+
+      const packageJson = {
+        dependencies: {
+          "@tanstack/react-query": "^5.90.2",
+        },
+      };
+
+      const missingDeps = requiredDeps.filter(
+        (dep) =>
+          !(
+            (packageJson.dependencies && packageJson.dependencies[dep.name]) ||
+            (packageJson.devDependencies &&
+              packageJson.devDependencies[dep.name])
+          )
+      );
+
+      expect(missingDeps).toHaveLength(1);
+      expect(missingDeps[0].name).toBe("recharts");
+    });
+
+    it("should return empty array when all dependencies are present", () => {
+      const requiredDeps = [
+        { name: "react", version: "^18.0.0" },
+        { name: "vite", version: "^5.0.0" },
+      ];
+
+      const packageJson = {
+        dependencies: {
+          react: "^18.0.0",
+        },
+        devDependencies: {
+          vite: "^5.0.0",
+        },
+      };
+
+      const missingDeps = requiredDeps.filter(
+        (dep) =>
+          !(
+            (packageJson.dependencies && packageJson.dependencies[dep.name]) ||
+            (packageJson.devDependencies &&
+              packageJson.devDependencies[dep.name])
+          )
+      );
+
+      expect(missingDeps).toHaveLength(0);
+    });
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cognite-create",
-  "version": "0.2.31",
+  "version": "0.2.33",
   "description": "Create a Next.js app preconfigured with Cognite defaults.",
   "bin": {
     "cognite-create": "./bin/index.js"
@@ -9,8 +9,15 @@
     "bin",
     "templates"
   ],
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
   "engines": {
     "node": ">=18.0.0"
   },
+  "devDependencies": {
+    "vitest": "^2.1.0"
+  },
   "license": "UNLICENSED"
 }

package/templates/components.json

@@ -19,6 +19,6 @@
     "hooks": "@/hooks"
   },
   "registries": {
-    "@cognite": "https://liz-playground.vercel.app/r/{name}.json"
+    "@cognite/aura": "https://refactored-couscous-5l9mkl3.pages.github.io/r/{name}.json"
   }
 }