@cellajs/create-cella 0.0.4 → 0.0.6

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

@@ -0,0 +1,57 @@
+import { spawn } from 'node:child_process';
+
+type GitCommandType = 'merge' | 'diff' | 'other';
+
+interface RunGitCommandOptions {
+  targetFolder: string;
+  command: string;
+}
+
+// Helper to determine the type of Git command for custom handling
+function getGitCommandType(command: string): GitCommandType {
+  if (command.startsWith('merge')) return 'merge';
+  if (command.startsWith('diff')) return 'diff';
+  return 'other';
+}
+
+// Helper to check if a Git command is successful
+function isGitCommandSuccess(gitCommand: GitCommandType, code: number | null, errOutput: string): boolean {
+  if (gitCommand === 'merge') return code === 0 || (code === 1 && !errOutput);
+  if (gitCommand === 'diff') return code === 0 || (code === 2 && !errOutput);
+  return code === 0;
+}
+
+// Function to run a Git command and handle its output
+export async function runGitCommand({ targetFolder, command }: RunGitCommandOptions): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const gitCommand = getGitCommandType(command);
+    const child = spawn(`git ${command}`, [], { cwd: targetFolder, shell: true, timeout: 60000 });
+
+    let output = '';
+    let errOutput = '';
+
+    child.on('error', (error: Error) => {
+      reject(error);
+    });
+
+    child.on('exit', (code: number | null) => {
+      if (isGitCommandSuccess(gitCommand, code, errOutput)) {
+        resolve(output.trim());
+      } else {
+        reject(
+          `Git ${gitCommand} command failed with exit code ${code}, stderr: "${errOutput.trim()}", stdout: "${output.trim()}"`
+        );
+      }
+    });
+
+    // Collect stdout data
+    child.stdout.on('data', (data: Buffer) => {
+      output += data.toString();
+    });
+
+    // Collect stderr data
+    child.stderr.on('data', (data: Buffer) => {
+      errOutput += data.toString();
+    });
+  });
+}

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

@@ -0,0 +1,74 @@
+import spawn from 'cross-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.
+ * @returns A promise that resolves if the command executes successfully; otherwise, it rejects with an error message.
+ */
+export async function runPackageManagerCommand(
+  packageManager: string,
+  args: string[],
+  env: Record<string, string> = {}
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = 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();
+    });
+  });
+}
+
+/**
+ * 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.
+ */
+export async function install(packageManager: string): Promise<void> {
+  return runPackageManagerCommand(packageManager, ['install'], {
+    NODE_ENV: 'development',
+  });
+}
+
+/**
+ * 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.
+ */
+export async function generate(packageManager: string): Promise<void> {
+  return runPackageManagerCommand(packageManager, ['generate'], {
+    NODE_ENV: 'development',
+  });
+}

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

@@ -0,0 +1,22 @@
+import validate from 'validate-npm-package-name';
+
+interface ValidationResult {
+  valid: boolean;
+  problems?: string[];
+}
+
+export function validateProjectName(name: string): ValidationResult {
+  const nameValidation = validate(name);
+
+  if (nameValidation.validForNewPackages) {
+    return { valid: true };
+  }
+
+  return {
+    valid: false,
+    problems: [
+      ...(nameValidation.errors || []),
+      ...(nameValidation.warnings || []),
+    ],
+  };
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 CellaJS
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/index.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-
-import './src/index.js';

package/src/cli.js

@@ -1,94 +0,0 @@
-import { basename, resolve } from 'node:path'
-import { Command, InvalidArgumentError } from 'commander'
-
-import { NAME } from './constants.js'
-
-import { packageJson } from './utils/package-json.js'
-import { validateProjectName } from './utils/validate-project-name.js'
-
-// Initialize CLI variables
-let directory = null;
-let newBranchName = null;
-let createNewBranch = null;
-const packageManager = 'pnpm';
-
-// Set up the CLI command using Commander
-export const command = new Command(NAME)
-  .version(packageJson.version, '-v, --version', `Output the current version of ${NAME}.`)
-  .argument('[directory]', 'The directory name for the new project.')
-  .usage('[directory] [options]')
-  .helpOption('-h, --help', 'Display this help message.')
-  .option(
-    '--skip-new-branch',
-    'Skip creating a new branch during initialization.',
-    false,
-  )
-  .option(
-    '--skip-install',
-    'Skip the installation of packages.',
-    false,
-  )
-  .option(
-    '--skip-generate',
-    'Skip generating SQL files.',
-    false,
-  )
-  .option(
-    '--skip-clean',
-    'Skip cleaning the `cella` template.',
-    false,
-  )
-  .option(
-    '--skip-git',
-    'Skip initializing a git repository.',
-    false,
-  )
-  .option(
-      '--new-branch-name <name>',
-      'Specify a new branch name to create and use.',
-      (name) => {
-        if (typeof name === 'string') {
-          name = name.trim();
-        }
-
-        if (name) {
-          const validation = validateProjectName(basename(resolve(name)))
-          if (!validation.valid) throw new InvalidArgumentError(`Invalid branch name: ${validation.problems[0]}`);
-
-          createNewBranch = true;
-          newBranchName = name;
-        }
-      },
-  )
-  .action((name) => {
-      if (typeof name === 'string') {
-        name = name.trim()
-      }
-
-      if (name) {
-        const validation = validateProjectName(basename(resolve(name)));
-        if (!validation.valid) throw new InvalidArgumentError(`Invalid project name: ${validation.problems[0]}`);
-
-        directory = name;
-      }
-    })
-  .parse();
-
-// Gather the CLI options and arguments
-const options = command.opts({ 
-  skipNewBranch: false, 
-  skipClean: false,
-  skipGit: false, 
-  skipInstall: false,
-  skipGenerate: false,
- });
-
- // Export the CLI configuration for use in other modules
-export const cli = { 
-  options, 
-  args: command.args, 
-  directory, 
-  newBranchName, 
-  createNewBranch, 
-  packageManager,
-};

package/src/constants.js

@@ -1,39 +0,0 @@
-export const NAME = 'create-cella'
-
-// URL of the template repository
-export const TEMPLATE_URL = 'github:cellajs/cella';
-
-// Import package.json dynamically for version and website information
-import packageJson from '../package.json' with { type: 'json' };
-
-// Export version, website and author from package.json
-export const VERSION = packageJson.version;
-export const AUTHOR = packageJson.author;
-export const WEBSITE = packageJson.homepage;
-
-// Files or folders to be removed from the template after downloading
-export const TO_REMOVE = [
-    'info',
-    './cli/create-cella'
-];
-
-// Specific folder contents to be cleaned out from the template
-export const TO_CLEAN = [
-    './backend/drizzle'
-];
-
-// Files to copy/paste after downloading
-export const TO_COPY = {
-    './backend/.env.example': './backend/.env',
-    './tus/.env.example': './tus/.env',
-    './info/QUICKSTART.md': 'README.md',
-};
-
-// ASCII title for the CLI output
-export const CELLA_TITLE = `
-                         _ _            
-    ▒▓█████▓▒     ___ ___| | | __ _
-    ▒▓█   █▓▒    / __/ _ \\ | |/ _\` |
-    ▒▓█   █▓▒   | (_|  __/ | | (_| |
-    ▒▓█████▓▒    \\___\\___|_|_|\\__,_|
-`;

package/src/create.js

@@ -1,167 +0,0 @@
-import { mkdir } from 'node:fs/promises';
-import { existsSync } from 'node:fs'
-import { join, relative } from 'node:path';
-import colors from 'picocolors';
-import { downloadTemplate } from "giget";
-import yoctoSpinner from 'yocto-spinner';
-
-import { TEMPLATE_URL } from './constants.js';
-
-import { install, generate } from './utils/run-package-manager-command.js';
-import { cleanTemplate } from './utils/clean-template.js';
-import { runGitCommand } from './utils/run-git-command.js';
-
-export async function create({
-    projectName,
-    targetFolder,
-    newBranchName,
-    skipInstall,
-    skipGit,
-    skipClean,
-    skipGenerate,
-    packageManager,
-  }) {
-    // Save the original working directory
-    const originalCwd = process.cwd();
-
-    console.info();
-    
-    // Create the target folder if it doesn't exist
-    const createFolderSpinner = yoctoSpinner({
-        text: 'Creating project folder',
-    }).start();
-
-    await mkdir(targetFolder, { recursive: true });
-    process.chdir(targetFolder);
-
-    createFolderSpinner.success('Project folder created');
-
-    // Download the template from the specified URL
-    const downloadSpinner = yoctoSpinner({
-      text: 'Downloading `cella` template',
-    }).start();
-
-    await downloadTemplate(TEMPLATE_URL, {
-        cwd: process.cwd(),
-        dir: targetFolder,
-        force: true,
-        provider: "github",
-    });
-
-    downloadSpinner.success('`cella` template downloaded');
-
-    // Clean the template if the skipClean flag is not set
-    if (!skipClean) {
-      const cleanSpinner = yoctoSpinner({
-        text: 'cleaning `cella` template',
-      }).start();
-
-      try {
-        await cleanTemplate({ 
-          targetFolder,
-          projectName,
-        })
-        cleanSpinner.success('`cella` template cleaned')
-      } catch (e) {
-        console.error(e);
-        cleanSpinner.error('Failed to clean `cella` template');
-        process.exit(1);
-      }
-    } else {
-      console.info(`${colors.yellow('⚠')} --skip-clean > Skip cleaning \`cella\` template'`)
-    }
-
-    // Install dependencies if the skipInstall flag is not set
-    if (!skipInstall) {
-      const installSpinner = yoctoSpinner({
-        text: 'installing dependencies',
-      }).start();
-
-      try {
-        await install(packageManager)
-        installSpinner.success('Dependencies installed');
-      } catch (e) {
-        console.error(e);
-        installSpinner.error('Failed to install dependencies');
-        process.exit(1);
-      }
-    } else {
-      console.info(`${colors.yellow('⚠')} --skip-install > Skip installing dependencies`)
-    }
-
-    // Generate SQL files if the skipGenerate flag is not set
-    if (!skipGenerate) {
-      const installSpinner = yoctoSpinner({
-        text: 'generating SQL files',
-      }).start();
-
-      try {
-        await generate(packageManager)
-        installSpinner.success('SQL files generated');
-      } catch (e) {
-        console.error(e);
-        installSpinner.error('Failed to generate SQL files');
-        process.exit(1);
-      }
-    } else {
-      console.info(`${colors.yellow('⚠')} --skip-generate > Skip generating SQL files`)
-    }
-
-    // Initialize Git repository if skipGit flag is not set
-    if (!skipGit) {
-      const gitSpinner = yoctoSpinner({
-        text: 'initializing git repository',
-      }).start();
-
-      const gitFolderPath = join(targetFolder, '.git');
-
-      if (!existsSync(gitFolderPath)) {
-        try {
-          // Run Git commands to initialize the repository and make the first commit
-          await runGitCommand({ targetFolder, command: 'init' });
-          await runGitCommand({ targetFolder, command: 'add .' });
-          await runGitCommand({ targetFolder, command: 'commit -m "Initial commit"' });
-        
-          // If a new branch name is specified, create and checkout the branch
-          if (newBranchName) {
-            await runGitCommand({ targetFolder, command: `branch ${newBranchName}` });
-            await runGitCommand({ targetFolder, command: `checkout ${newBranchName}` });
-            gitSpinner.success(`Git repository initialized, initial commit created, and new branch ${newBranchName} created`);
-          } else {
-            gitSpinner.success('Git repository initialized and initial commit created');
-          }
-        
-        } catch (e) {
-          console.error(e);
-          gitSpinner.error('Failed to initialize Git repository or create branch');
-          process.exit(1);
-        }
-      } else {
-        gitSpinner.warning('Git repository already initialized > Skip git init')
-      }
-    } else {
-      console.info(`${colors.yellow('⚠')} --skip-git > Skip git init`)
-    }
-    
-    // Final success message indicating project creation
-    console.info()
-    console.info(`${colors.green('Success')} Created ${projectName} at ${targetFolder}`)
-    console.info()
-
-    // Check if the working directory needs to be changed
-    const needsCd = originalCwd !== targetFolder;
-    if (needsCd) {
-      // Calculate the relative path between the original working directory and the target folder
-      const relativePath = relative(originalCwd, targetFolder);
-
-      console.info('now go to your project using:')
-      console.info(colors.cyan(`  cd ./${relativePath}`)); // Adding './' to make it clear it's a relative path
-      console.info()
-    }
-    console.info(`${needsCd ? 'then ' : ''}quick start with:`)
-    console.info(colors.cyan(`  ${packageManager} quick`))
-    console.info()
-
-    console.info('Read the readme in project root for more info on how to get started!')
-    console.info(`Enjoy building ${projectName} using cella! 🎉`)
-  }

package/src/utils/clean-template.js

@@ -1,99 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import colors from 'picocolors';
-
-import { TO_CLEAN, TO_REMOVE, TO_COPY } from '../constants.js';
-
-/**
- * Cleans the specified template by removing designated folders and files.
- * @param {Object} params - Parameters containing targetFolder.
- * @param {string} params.targetFolder - The folder to clean.
- */
-export async function cleanTemplate({
-  targetFolder,
-  projectName,
-}) {
-  // Change the current working directory to targetFolder if not already set
-  if (process.cwd() !== targetFolder) {
-    process.chdir(targetFolder);
-  }
-
-  return new Promise(async (resolve, reject) => {
-    try {
-      // Copy specified files
-      for (const [src, dest] of Object.entries(TO_COPY)) {
-        const srcAbsolutePath = path.resolve(targetFolder, src);
-        const destAbsolutePath = path.resolve(targetFolder, dest);
-        await copyFile(srcAbsolutePath, destAbsolutePath);
-      }
-
-      // Clean specified folder contents
-      await Promise.all(TO_CLEAN.map(folderPath => {
-        const absolutePath = path.resolve(targetFolder, folderPath);
-        return removeFolderContents(absolutePath);
-      }));
-
-      // Remove specified files and folders
-      await Promise.all(TO_REMOVE.map(filePath => {
-        const absolutePath = path.resolve(targetFolder, filePath);
-        return removeFileOrFolder(absolutePath);
-      }));
-
-      resolve();
-    } catch (err) {
-      reject(`Error during the cleaning process: ${err}`);
-    }
-  });
-}
-
-/**
- * Removes all contents within a specified folder.
- * @param {string} folderPath - The path of the folder to clean.
- */
-export async function removeFolderContents(folderPath) {
-  // List all files in the folder
-  const files = await fs.readdir(folderPath); 
-
-  await Promise.all(files.map(async (file) => {
-    const filePath = path.join(folderPath, file);
-
-    // Get the file or folder statistics
-    const stat = await fs.lstat(filePath);
-
-    // If it's a directory, remove it and all its contents
-    if (stat.isDirectory()) {
-      await fs.rm(filePath, { recursive: true, force: true });
-    } else {
-      // If it's a file, remove it
-      await fs.rm(filePath);
-    }
-  }));
-}
-
-/**
- * Removes a specified file or folder.
- * @param {string} pathToRemove - The path to the file or folder to remove.
- */
-export async function removeFileOrFolder(pathToRemove) {
-  await fs.rm(pathToRemove, { recursive: true, force: true });
-}
-
-// Helper function to copy files if the source exists
-export async function copyFile(src, dest) {
-  try {
-    // Check if the source file exists
-    await fs.access(src);
-
-    // Ensure the destination directory exists
-    await fs.mkdir(path.dirname(dest), { recursive: true });
-    
-    // Copy the file
-    await fs.copyFile(src, dest);
-  } catch (err) {
-    if (err.code === 'ENOENT') {
-      console.info(`\n${colors.yellow('⚠')} Source file "${src}" does not exist > Skip copy`);
-    } else {
-      throw err;
-    }
-  }
-}

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

@@ -1,15 +0,0 @@
-import { readdir } from 'node:fs/promises'
-
-/**
- * Checks if a directory is empty or only contains a .git directory.
- * 
- * @param {string} path - The path of the directory to check.
- * @returns {Promise<boolean>} - Resolves to true if the directory is empty or contains only a .git folder, false otherwise.
- * @throws {Error} - Throws an error if the path is not a directory or if there's an issue reading the directory.
- */
-export async function isEmptyDirectory(path) {
-  const files = await readdir(path);
-
-  // Check if directory is empty or contains only the .git directory
-  return files.length === 0 || (files.length === 1 && files[0] === '.git');
-}

package/src/utils/package-json.js

@@ -1,22 +0,0 @@
-import { readFile } from 'node:fs/promises'
-import { resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-/**
- * Reads and parses the package.json file located in the root directory.
- * 
- * @returns {Promise<object>} - A promise that resolves to the parsed package.json object.
- * @throws {Error} - Throws an error if the package.json file cannot be found or read, or if the JSON is invalid.
- */
-async function readPackageJson() {
-  const PACKAGE_JSON_FILE = resolve(
-    fileURLToPath(import.meta.url),
-    '../../../package.json',
-  );
-
-  const packageJson = await readFile(PACKAGE_JSON_FILE, 'utf-8')
-  return JSON.parse(packageJson)
-}
-
-// Load the package.json at module initialization
-export const packageJson = await readPackageJson()

package/src/utils/run-git-command.js

@@ -1,39 +0,0 @@
-import { spawn } from "node:child_process";
-
-/**
- * Executes a Git command in the specified target folder.
- * 
- * @param {Object} options - Options for running the Git command.
- * @param {string} options.targetFolder - The folder in which to run the command.
- * @param {string} options.command - The Git command to execute (e.g., 'init', 'commit -m "message"', etc.).
- * @returns {Promise<void>} - A promise that resolves if the command executes successfully; otherwise, it rejects with an error message.
- * @throws {Error} - Throws an error if the Git command fails or if there is an error starting the process.
- */
-export async function runGitCommand({ targetFolder, command }) {
-    return new Promise((resolve, reject) => {
-      const child = spawn(`git ${command}`, [], { 
-        cwd: targetFolder, 
-        shell: true, 
-        timeout: 60000,
-      });
-  
-      // Handle process errors
-      child.on("error", (error) => {
-        reject(error);
-      });
-  
-      // Handle command exit
-      child.on("exit", (code) => {
-        if (code === 0) {
-          resolve();
-        } else {
-          reject(`Git command failed with exit code ${code}`);
-        }
-      });
-  
-      // Swallow stdout and stderr
-      child.stdout.on("data", () => {});
-      child.stderr.on("data", () => {});
-    });
-  }
-