cognite-create 0.2.32 → 0.2.33

package/bin/index.js

@@ -19,6 +19,12 @@ 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,
@@ -56,6 +62,14 @@ async function main() {
     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];
   await runCreateVite(createArgs);
   await addCogniteTemplates(projectDir);
@@ -206,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;
   }
@@ -221,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;
 }
@@ -271,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}`);
@@ -306,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

@@ -39,6 +39,102 @@ describe("CLI Command Tests", () => {
       ]);
     });
 
+    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;
@@ -131,10 +227,17 @@ describe("CLI Command Tests", () => {
         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) {
+    function getInstallCommand(packageManager, dependencySpecs, isDev = false) {
       const normalizeCommand = (cmd) => {
         if (process.platform === "win32" && cmd !== "bun") {
           return `${cmd}.cmd`;
@@ -143,16 +246,17 @@ describe("CLI Command Tests", () => {
       };
 
       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: [] };
       }
@@ -163,21 +267,41 @@ describe("CLI Command Tests", () => {
       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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cognite-create",
-  "version": "0.2.32",
+  "version": "0.2.33",
   "description": "Create a Next.js app preconfigured with Cognite defaults.",
   "bin": {
     "cognite-create": "./bin/index.js"

package/templates/vite.config.ts

@@ -0,0 +1,14 @@
+import path from "path"
+import tailwindcss from "@tailwindcss/vite"
+import react from "@vitejs/plugin-react"
+import { defineConfig } from "vite"
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+    },
+  },
+})