@cellajs/create-cella 0.1.5 → 0.2.0

package/src/utils/git/command.ts

@@ -0,0 +1,89 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Executes a Git command in a specific repository path and returns the trimmed stdout.
+ * Uses execFile for safety (no shell injection) aligned with sync package pattern.
+ *
+ * @param args - The Git command arguments to execute (e.g., ['status'], ['checkout', 'branch-name']).
+ * @param repoPath - The path to the Git repository.
+ * @param options - Optional settings for command execution.
+ * @returns The stdout of the Git command, trimmed of leading and trailing whitespace.
+ */
+export async function runGitCommand(
+  args: string[],
+  repoPath: string,
+  options: { skipEditor?: boolean; maxBuffer?: number } = {},
+): Promise<string> {
+  const gitArgs = repoPath ? ['-C', repoPath, ...args] : args;
+
+  const env = {
+    ...process.env,
+    ...(options.skipEditor ? { GIT_EDITOR: 'true' } : {}),
+  };
+
+  // Default to 10MB buffer for typical outputs
+  const maxBuffer = options.maxBuffer ?? 10 * 1024 * 1024;
+
+  const { stdout } = await execFileAsync('git', gitArgs, { env, maxBuffer });
+
+  return stdout.trim();
+}
+
+/**
+ * Initializes a new Git repository in the specified directory.
+ */
+export async function gitInit(repoPath: string): Promise<string> {
+  return runGitCommand(['init'], repoPath);
+}
+
+/**
+ * Stages all files in the repository.
+ */
+export async function gitAddAll(repoPath: string): Promise<string> {
+  return runGitCommand(['add', '.'], repoPath);
+}
+
+/**
+ * Creates a commit with the specified message.
+ */
+export async function gitCommit(repoPath: string, message: string): Promise<string> {
+  return runGitCommand(['commit', '-m', message], repoPath);
+}
+
+/**
+ * Creates a new branch with the specified name.
+ */
+export async function gitBranch(repoPath: string, branchName: string): Promise<string> {
+  return runGitCommand(['branch', branchName], repoPath);
+}
+
+/**
+ * Checks out the specified branch.
+ */
+export async function gitCheckout(repoPath: string, branchName: string): Promise<string> {
+  return runGitCommand(['checkout', branchName], repoPath);
+}
+
+/**
+ * Gets the URL of a remote.
+ */
+export async function gitRemoteGetUrl(repoPath: string, remoteName: string): Promise<string> {
+  return runGitCommand(['remote', 'get-url', remoteName], repoPath);
+}
+
+/**
+ * Adds a new remote.
+ */
+export async function gitRemoteAdd(repoPath: string, remoteName: string, remoteUrl: string): Promise<string> {
+  return runGitCommand(['remote', 'add', remoteName, remoteUrl], repoPath);
+}
+
+/**
+ * Removes a remote.
+ */
+export async function gitRemoteRemove(repoPath: string, remoteName: string): Promise<string> {
+  return runGitCommand(['remote', 'remove', remoteName], repoPath);
+}

package/src/utils/git/index.ts

@@ -0,0 +1,11 @@
+export {
+  gitAddAll,
+  gitBranch,
+  gitCheckout,
+  gitCommit,
+  gitInit,
+  gitRemoteAdd,
+  gitRemoteGetUrl,
+  gitRemoteRemove,
+  runGitCommand,
+} from './command';

package/src/utils/is-empty-directory.ts

@@ -2,7 +2,7 @@ import { readdir } from 'node:fs/promises';
 
 /**
  * Checks if a directory is empty or only contains a .git directory.
- * 
+ *
  * @param path - The path of the directory to check.
  * @returns Resolves to true if the directory is empty or contains only a .git folder, false otherwise.
  * @throws Throws an error if the path is not a directory or if there's an issue reading the directory.

package/src/utils/progress.ts

@@ -0,0 +1,118 @@
+/**
+ * Progress Tracker Utility
+ *
+ * Provides compact progress tracking for CLI operations.
+ * Uses a single spinner that updates in place.
+ */
+
+import ora, { type Ora } from 'ora';
+import pc from 'picocolors';
+
+/** Global reference to the currently active spinner */
+let activeSpinner: Ora | null = null;
+
+/** Pause the active spinner (for interactive prompts) */
+export function pauseSpinner(): void {
+  if (activeSpinner) {
+    activeSpinner.stop();
+  }
+}
+
+/** Resume the active spinner after a prompt */
+export function resumeSpinner(): void {
+  if (activeSpinner) {
+    activeSpinner.start();
+  }
+}
+
+export interface ProgressTracker {
+  /** Update the current step (shown as spinner text) */
+  step: (message: string) => void;
+  /** Mark the tracker as complete with final message */
+  done: (message: string) => void;
+  /** Mark the tracker as failed with error message */
+  fail: (message: string) => void;
+  /** Wrap an async operation to auto-fail on error */
+  wrap: <T>(fn: () => Promise<T>) => Promise<T>;
+}
+
+/**
+ * Creates a progress tracker for a multi-step operation.
+ * Shows a single spinner that updates in place.
+ *
+ * @param title - The initial title for the spinner
+ * @returns A ProgressTracker instance
+ *
+ * @example
+ * const progress = createProgress('creating project');
+ * progress.step('downloading template');
+ * progress.step('installing dependencies');
+ * progress.done('project created');
+ */
+export function createProgress(title: string, silent = false): ProgressTracker {
+  const completedSteps: string[] = [];
+
+  const spinner = ora({
+    text: title,
+    isSilent: silent,
+  });
+
+  activeSpinner = spinner;
+  spinner.start();
+
+  // Helper to log (respects silent mode)
+  const log = (msg: string) => {
+    if (!silent) console.info(msg);
+  };
+
+  return {
+    step: (message: string) => {
+      // Complete previous step with green check if there was one
+      if (completedSteps.length > 0) {
+        spinner.stop();
+        log(`${pc.green('✓')} ${completedSteps[completedSteps.length - 1]}`);
+      }
+      completedSteps.push(message);
+      spinner.text = message;
+      spinner.start();
+    },
+
+    done: (message: string) => {
+      // Complete the last step with green check
+      if (completedSteps.length > 0) {
+        spinner.stop();
+        log(`${pc.green('✓')} ${completedSteps[completedSteps.length - 1]}`);
+      } else {
+        spinner.stop();
+      }
+      activeSpinner = null;
+      if (message) {
+        log('');
+        log(`${pc.green('✓')} ${message}`);
+      }
+    },
+
+    fail: (message: string) => {
+      spinner.stop();
+      activeSpinner = null;
+      log(`${pc.red('✗')} ${pc.red(message)}`);
+    },
+
+    wrap: async <T>(fn: () => Promise<T>): Promise<T> => {
+      try {
+        return await fn();
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // Stop spinner and show tree-style breakdown on failure
+        spinner.stop();
+        activeSpinner = null;
+        log(pc.cyan(`\n${title}`));
+        for (const step of completedSteps) {
+          log(pc.gray(`  ├─ ${step}`));
+        }
+        log(pc.red(`  └─ ✗ ${errorMessage}`));
+        throw error;
+      }
+    },
+  };
+}

package/src/utils/run-package-manager-command.ts

@@ -1,8 +1,8 @@
-import spawn from 'cross-spawn';
+import spawn from 'nano-spawn';
 
 /**
  * Executes a command using the specified package manager (e.g., pnpm).
- * 
+ *
  * @param packageManager - The package manager to use (e.g., 'pnpm').
  * @param args - The arguments to pass to the package manager command.
  * @param env - Additional environment variables to set during command execution.
@@ -11,47 +11,22 @@ import spawn from 'cross-spawn';
 export async function runPackageManagerCommand(
   packageManager: string,
   args: string[],
-  env: Record<string, string> = {}
+  env: Record<string, string> = {},
 ): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const child = spawn(packageManager, args, {
-      env: {
-        ...process.env,
-        ...env,
-      },
+  try {
+    await spawn(packageManager, args, {
+      env: { ...process.env, ...env },
       stdio: ['pipe', 'pipe', 'pipe'],
     });
-
-    // Buffer for capturing stderr and stdout output
-    let stderrBuffer = '';
-    let stdoutBuffer = '';
-
-    // Capture stderr output
-    child.stderr?.on('data', (data: Buffer) => {
-      stderrBuffer += data.toString();
-    });
-
-    // Capture stdout output
-    child.stdout?.on('data', (data: Buffer) => {
-      stdoutBuffer += data.toString();
-    });
-
-    // Handle process exit
-    child.on('close', (code: number | null) => {
-      if (code !== 0) {
-        reject(
-          `"${packageManager} ${args.join(' ')}" failed ${stdoutBuffer} ${stderrBuffer}`
-        );
-        return;
-      }
-      resolve();
-    });
-  });
+  } catch (error) {
+    const err = error as { stdout?: string; stderr?: string };
+    throw new Error(`"${packageManager} ${args.join(' ')}" failed ${err.stdout || ''} ${err.stderr || ''}`);
+  }
 }
 
 /**
  * Installs dependencies using the specified package manager.
- * 
+ *
  * @param packageManager - The package manager to use for installation (e.g., 'pnpm').
  * @returns A promise that resolves if the installation completes successfully; otherwise, it rejects with an error.
  */
@@ -63,7 +38,7 @@ export async function install(packageManager: string): Promise<void> {
 
 /**
  * Generates SQL files using the specified package manager.
- * 
+ *
  * @param packageManager - The package manager to use for generation (e.g., 'pnpm').
  * @returns A promise that resolves if the generation completes successfully; otherwise, it rejects with an error.
  */

package/src/utils/validate-project-name.ts

@@ -14,9 +14,6 @@ export function validateProjectName(name: string): ValidationResult {
 
   return {
     valid: false,
-    problems: [
-      ...(nameValidation.errors || []),
-      ...(nameValidation.warnings || []),
-    ],
+    problems: [...(nameValidation.errors || []), ...(nameValidation.warnings || [])],
   };
 }

package/tests/e2e.test.ts

@@ -0,0 +1,108 @@
+import { existsSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { create } from '#/create';
+
+/**
+ * E2E test for create-cella CLI.
+ * This test does a full install and verifies the project is set up correctly.
+ * Note: This test is slow (~60s+) as it runs pnpm install and generate.
+ */
+describe('create-cella e2e', () => {
+  const projectName = `cella-e2e-test-${Date.now()}`;
+  const targetFolder = join(tmpdir(), projectName);
+
+  beforeAll(async () => {
+    // Create a full project with all steps
+    await create({
+      projectName,
+      targetFolder,
+      newBranchName: 'development',
+      packageManager: 'pnpm',
+      silent: true,
+    });
+  }, 120000); // 2 minute timeout for full install
+
+  afterAll(() => {
+    // Cleanup
+    if (existsSync(targetFolder)) {
+      rmSync(targetFolder, { recursive: true, force: true });
+    }
+  });
+
+  describe('project structure', () => {
+    it('should create essential directories', () => {
+      expect(existsSync(join(targetFolder, 'backend'))).toBe(true);
+      expect(existsSync(join(targetFolder, 'frontend'))).toBe(true);
+      expect(existsSync(join(targetFolder, 'config'))).toBe(true);
+      expect(existsSync(join(targetFolder, 'locales'))).toBe(true);
+    });
+
+    it('should have node_modules installed', () => {
+      expect(existsSync(join(targetFolder, 'node_modules'))).toBe(true);
+      expect(existsSync(join(targetFolder, 'backend', 'node_modules'))).toBe(true);
+      expect(existsSync(join(targetFolder, 'frontend', 'node_modules'))).toBe(true);
+    });
+  });
+
+  describe('README.md (from QUICKSTART)', () => {
+    it('should have README.md with quickstart content', () => {
+      const readmePath = join(targetFolder, 'README.md');
+      expect(existsSync(readmePath)).toBe(true);
+
+      const content = readFileSync(readmePath, 'utf-8');
+      // Check for QUICKSTART.md content markers
+      expect(content).toContain('# Quickstart');
+      expect(content).toContain('pnpm quick');
+      expect(content).toContain('pnpm docker');
+    });
+  });
+
+  describe('.env files', () => {
+    it('should have backend .env file', () => {
+      const envPath = join(targetFolder, 'backend', '.env');
+      expect(existsSync(envPath)).toBe(true);
+    });
+
+    it('should have frontend .env file', () => {
+      const envPath = join(targetFolder, 'frontend', '.env');
+      expect(existsSync(envPath)).toBe(true);
+    });
+  });
+
+  describe('database migrations', () => {
+    it('should have generated drizzle migrations', () => {
+      const drizzlePath = join(targetFolder, 'backend', 'drizzle');
+      expect(existsSync(drizzlePath)).toBe(true);
+
+      // Check that migration files exist (at least one .sql file)
+      const files = readdirSync(drizzlePath);
+      const sqlFiles = files.filter((f) => f.endsWith('.sql'));
+      expect(sqlFiles.length).toBeGreaterThan(0);
+    });
+
+    it('should have drizzle meta folder', () => {
+      const metaPath = join(targetFolder, 'backend', 'drizzle', 'meta');
+      expect(existsSync(metaPath)).toBe(true);
+    });
+  });
+
+  describe('git repository', () => {
+    it('should have initialized git', () => {
+      expect(existsSync(join(targetFolder, '.git'))).toBe(true);
+    });
+
+    it('should be on development branch', () => {
+      const gitHead = readFileSync(join(targetFolder, '.git', 'HEAD'), 'utf-8');
+      expect(gitHead.trim()).toBe('ref: refs/heads/development');
+    });
+
+    it('should have upstream remote configured', () => {
+      const configPath = join(targetFolder, '.git', 'config');
+      const config = readFileSync(configPath, 'utf-8');
+      expect(config).toContain('[remote "upstream"]');
+      expect(config).toContain('cellajs/cella');
+    });
+  });
+});

package/tests/validate-project-name.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+
+import { validateProjectName } from '#/utils/validate-project-name';
+
+describe('validateProjectName', () => {
+  it('should accept valid project names', () => {
+    expect(validateProjectName('my-app')).toEqual({ valid: true });
+    expect(validateProjectName('my-cella-app')).toEqual({ valid: true });
+    expect(validateProjectName('app123')).toEqual({ valid: true });
+  });
+
+  it('should reject invalid project names', () => {
+    const result = validateProjectName('My App');
+    expect(result.valid).toBe(false);
+    expect(result.problems).toBeDefined();
+  });
+
+  it('should reject names starting with dots or underscores', () => {
+    expect(validateProjectName('.hidden').valid).toBe(false);
+    expect(validateProjectName('_private').valid).toBe(false);
+  });
+});

package/tsconfig.json

@@ -1,15 +1,20 @@
 {
-    "extends": "../../tsconfig.json",
-    "compilerOptions": {
-      "jsx": "react-jsx",
-      "target": "ESNext",
-      "module": "ESNext",
-
-      "strict": false,
-      "incremental": false,
-      "declaration": true,
-      "composite": false,
-    },
-    "moduleResolution": "Bundler",
-    "include": ["src", "tsup.config.ts"]
-  }
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "target": "ESNext",
+    "module": "ESNext",
+    "strict": true,
+    "incremental": true,
+    "tsBuildInfoFile": ".tsbuildinfo",
+    "declaration": true,
+    "composite": false,
+    "skipLibCheck": true,
+    "types": ["node"],
+    "paths": {
+      "#/*": ["./src/*"]
+    }
+  },
+  "include": ["src", "tests", "index.js", "tsup.config.ts"]
+}

package/tsup.config.ts

@@ -1,7 +1,8 @@
+import { resolve } from 'node:path';
 import { defineConfig } from 'tsup';
 
 export default defineConfig({
-  entry: ['src/index.ts'],
+  entry: { index: 'src/create-cella-cli.ts' },
   outDir: 'dist',
   clean: true,
   minify: false,
@@ -12,11 +13,11 @@ export default defineConfig({
   dts: false,
   esbuildOptions(options) {
     options.alias = {
-      '#': './src',
+      '#': resolve(__dirname, './src'),
     };
-    options.platform = 'node'; // Ensure the platform is set to Node.js
-    options.mainFields = ['module', 'main']; // Prioritize ESM entry points
-    options.conditions = ['module']; // Enforce use of ESM
+    options.platform = 'node';
+    options.mainFields = ['module', 'main'];
+    options.conditions = ['module'];
   },
   external: [],
 });

package/vitest.config.ts

@@ -0,0 +1,17 @@
+import { resolve } from 'node:path';
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      '#': resolve(__dirname, './src'),
+    },
+  },
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.test.ts', 'tests/**/*.test.ts'],
+    testTimeout: 120000, // 2 minutes for E2E tests
+    onConsoleLog: () => false, // Suppress console output during tests
+  },
+});