cognite-create 0.2.32 → 0.2.34

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);
@@ -112,47 +126,39 @@ async function addCogniteTemplates(projectDir) {
 
     if (pathSegments[0] === "app" || pathSegments[0] === "lib") {
       const target = path.join(srcDirectory, ...pathSegments);
-      const isGlobalsCss =
-        pathSegments[0] === "app" &&
-        pathSegments.length === 2 &&
-        pathSegments[1] === "globals.css";
-
-      if (isGlobalsCss) {
-        await copyFileWithOverwrite(source, target);
-      } else {
-        await copyFileIfMissing(source, target);
-      }
-
+      // Overwrite template files in src/app and src/lib
+      await copyFileWithOverwrite(source, target);
       continue;
     }
 
+    // Overwrite root-level configuration files
     const target = path.join(targetRoot, relativePath);
-    await copyFileIfMissing(source, target);
+    await copyFileWithOverwrite(source, target);
   }
 
   console.log("\nCognite templates copied successfully.");
 }
 
-async function copyFileIfMissing(source, target) {
+async function copyFileWithOverwrite(source, target) {
   await fs.mkdir(path.dirname(target), { recursive: true });
 
+  let fileExists = false;
   try {
     await fs.access(target);
-    console.warn(`Skipped existing ${path.relative(process.cwd(), target)}`);
+    fileExists = true;
   } catch (error) {
     if (error.code !== "ENOENT") {
       throw error;
     }
-
-    await fs.copyFile(source, target);
-    console.log(`Added ${path.relative(process.cwd(), target)}`);
   }
-}
 
-async function copyFileWithOverwrite(source, target) {
-  await fs.mkdir(path.dirname(target), { recursive: true });
   await fs.copyFile(source, target);
-  console.log(`Replaced ${path.relative(process.cwd(), target)}`);
+
+  if (fileExists) {
+    console.log(`Replaced ${path.relative(process.cwd(), target)}`);
+  } else {
+    console.log(`Added ${path.relative(process.cwd(), target)}`);
+  }
 }
 
 async function collectTemplateFiles(rootDir) {
@@ -206,7 +212,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 +227,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 +301,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 +346,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.34",
   "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"),
+    },
+  },
+})