@cellajs/create-cella 0.0.5 → 0.0.7

package/index.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cellajs/create-cella",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "private": false,
   "license": "MIT",
   "description": "Create your own app in seconds with Cella: a TypeScript template for local-first web apps.",
@@ -18,10 +18,14 @@
     "node": ">=20.14.0"
   },
   "type": "module",
-  "main": "index.js",
+  "main": "index.ts",
   "bin": {
-    "create-cella": "index.js"
+    "create-cella": "index.ts"
   },
+  "scripts": {
+    "create": "tsx index.ts"
+  },
+  "packageManager": "pnpm@9.11.0",
   "dependencies": {
     "@inquirer/prompts": "^6.0.1",
     "commander": "^12.1.0",
@@ -31,7 +35,7 @@
     "validate-npm-package-name": "^5.0.1",
     "yocto-spinner": "^0.1.0"
   },
-  "scripts": {
-    "create": "node index.js"
+  "devDependencies": {
+    "tsx": "^4.19.2"
   }
-}
+}

package/src/add-remote.ts

@@ -0,0 +1,55 @@
+import yoctoSpinner from 'yocto-spinner';
+import { runGitCommand } from './utils/run-git-command.ts';
+import { CELLA_REMOTE_URL } from './constants.ts';
+
+interface AddRemoteOptions {
+  targetFolder: string;
+  remoteUrl?: string; // Optional, defaults to CELLA_REMOTE_URL
+  remoteName?: string; // Optional, defaults to 'upstream'
+}
+
+export async function addRemote({
+  targetFolder,
+  remoteUrl = CELLA_REMOTE_URL,
+  remoteName = 'upstream',
+}: AddRemoteOptions): Promise<void> {
+
+  // Spinner for adding remote
+  const remoteSpinner = yoctoSpinner({
+    text: 'Adding remote',
+  }).start();
+
+  try {
+    // Check if the remote exists
+    let remote: string | null = null;
+
+    try {
+      remote = await runGitCommand({ targetFolder, command: `remote get-url ${remoteName}` });
+    } catch (error: any) {
+      // If the remote doesn't exist, it throws a fatal error
+      const errorMessage = typeof error === 'string' ? error : error?.message || '';
+      if (errorMessage.includes('fatal: No such remote')) {
+        remote = null;
+      } else {
+        throw error;
+      }
+    }
+
+    // Add or update the remote if it doesn't exist or differs from `remoteUrl`
+    if (!remote) {
+      await runGitCommand({ targetFolder, command: `remote add ${remoteName} ${remoteUrl}` });
+      remoteSpinner.success('Remote added successfully.');
+    } else if (remote !== remoteUrl) {
+      // Remove existing remote and set the new URL
+      await runGitCommand({ targetFolder, command: `remote remove ${remoteName}` });
+      await runGitCommand({ targetFolder, command: `remote add ${remoteName} ${remoteUrl}` });
+      remoteSpinner.success('Remote updated successfully.');
+    } else {
+      remoteSpinner.success('Remote is already configured correctly.');
+    }
+  } catch (error) {
+    console.error(error);
+    remoteSpinner.error('Failed to add remote.');
+    process.exit(1);
+  }
+}

package/src/cli.ts

@@ -0,0 +1,107 @@
+import { basename, resolve } from 'node:path';
+import { Command, InvalidArgumentError } from 'commander';
+
+import { NAME } from './constants.ts';
+import { packageJson } from './utils/package-json.ts';
+import { validateProjectName } from './utils/validate-project-name.ts';
+
+// Define types for CLI options
+interface CLIOptions {
+  skipNewBranch: boolean;
+  skipClean: boolean;
+  skipGit: boolean;
+  skipInstall: boolean;
+  skipGenerate: boolean;
+  newBranchName?: string;
+}
+
+// Define CLI configuration
+interface CLIConfig {
+  options: CLIOptions;
+  args: string[];
+  directory: string | null;
+  newBranchName: string | null;
+  createNewBranch: boolean | null;
+  packageManager: string;
+}
+
+// Initialize CLI variables
+let directory: string | null = null;
+let newBranchName: string | null = null;
+let createNewBranch: boolean | null = 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: string) => {
+        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: string) => {
+    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: CLIOptions = command.opts<CLIOptions>({
+  skipNewBranch: false,
+  skipClean: false,
+  skipGit: false,
+  skipInstall: false,
+  skipGenerate: false,
+});
+
+// Export the CLI configuration for use in other modules
+export const cli: CLIConfig = {
+  options,
+  args: command.args,
+  directory,
+  newBranchName,
+  createNewBranch,
+  packageManager,
+};

package/src/constants.ts

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

package/src/create.ts

@@ -0,0 +1,183 @@
+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.ts';
+
+import { install, generate } from './utils/run-package-manager-command.ts';
+import { cleanTemplate } from './utils/clean-template.ts';
+import { runGitCommand } from './utils/run-git-command.ts';
+import { addRemote } from './add-remote.ts';
+
+interface CreateOptions {
+  projectName: string;
+  targetFolder: string;
+  newBranchName?: string | null;
+  skipInstall: boolean;
+  skipGit: boolean;
+  skipClean: boolean;
+  skipGenerate: boolean;
+  packageManager: string;
+}
+
+export async function create({
+  projectName,
+  targetFolder,
+  newBranchName,
+  skipInstall,
+  skipGit,
+  skipClean,
+  skipGenerate,
+  packageManager,
+}: CreateOptions): Promise<void> {
+  // 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 generateSpinner = yoctoSpinner({
+      text: 'generating SQL files',
+    }).start();
+
+    try {
+      await generate(packageManager);
+      generateSpinner.success('SQL files generated');
+    } catch (e) {
+      console.error(e);
+      generateSpinner.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`);
+  }
+
+  // Add Cella as upstream remote
+  await addRemote({ targetFolder });
+
+  // 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('Check out the readme to get started: /README.md');
+  console.info(`Enjoy building ${projectName} using cella! 🎉`);
+  console.info();
+}

package/src/{index.js → index.ts}

@@ -1,17 +1,28 @@
-#!/usr/bin/env node
+#!/usr/bin/env tsx
 
-import { basename, resolve } from 'node:path'
-import { existsSync } from 'node:fs'
+import { basename, resolve } from 'node:path';
+import { existsSync } from 'node:fs';
 
 import { input, confirm, select } from '@inquirer/prompts';
 
-import { cli } from './cli.js'
-import { validateProjectName } from './utils/validate-project-name.js'
-import { isEmptyDirectory } from './utils/is-empty-directory.js'
-import { create } from './create.js'
-import { CELLA_TITLE, VERSION, WEBSITE, AUTHOR } from './constants.js'
+import { cli } from './cli';
+import { validateProjectName } from './utils/validate-project-name.ts';
+import { isEmptyDirectory } from './utils/is-empty-directory.ts';
+import { create } from './create.ts';
+import { CELLA_TITLE, VERSION, WEBSITE, AUTHOR } from './constants.ts';
+
+interface CreateOptions {
+  projectName: string;
+  targetFolder: string;
+  newBranchName?: string | null;
+  skipInstall: boolean;
+  skipGit: boolean;
+  skipClean: boolean;
+  skipGenerate: boolean;
+  packageManager: string;
+}
 
-async function main() {
+async function main(): Promise<void> {
   console.info(CELLA_TITLE);
 
   // Display CLI version and created by information
@@ -28,7 +39,7 @@ async function main() {
   }
 
   // Skip generating sql files if --skipGenerate flag is provided
-  if (cli.options.skipGenerate === true) { 
+  if (cli.options.skipGenerate === true) {
     cli.options.skipGenerate = true;
   }
 
@@ -73,14 +84,14 @@ async function main() {
       message: 'Enter the new branch name',
       default: 'development',
       validate: (name) => {
-        const validation = validateProjectName(basename(resolve(name)))
+        const validation = validateProjectName(basename(resolve(name)));
         return validation.valid ? true : `Invalid branch name: ${validation.problems[0]}`;
       },
     });
   }
 
-  const targetFolder = resolve(cli.directory)
-  const projectName = basename(targetFolder)
+  const targetFolder = resolve(cli.directory);
+  const projectName = basename(targetFolder);
 
   // Check if the target folder exists and is not empty
   if (existsSync(targetFolder) && !(await isEmptyDirectory(targetFolder))) {
@@ -94,13 +105,14 @@ async function main() {
         { name: 'Ignore existing files and continue', value: 'ignore' },
       ],
     });
+
     if (action === 'cancel') {
       process.exit(1);
     }
   }
-  
+
   // Proceed with the project creation
-  await create({
+  const createOptions: CreateOptions = {
     projectName,
     targetFolder,
     newBranchName: cli.newBranchName,
@@ -109,7 +121,9 @@ async function main() {
     skipClean: cli.options.skipClean,
     skipGenerate: cli.options.skipGenerate,
     packageManager: cli.packageManager,
-  });
+  };
+
+  await create(createOptions);
 }
 
-main().catch(console.error)
+main().catch(console.error);

package/src/utils/clean-template.ts

@@ -0,0 +1,111 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import colors from 'picocolors';
+
+import { TO_CLEAN, TO_REMOVE, TO_COPY } from '../constants.ts';
+
+/**
+ * Cleans the specified template by removing designated folders and files.
+ * @param params - Parameters containing the target folder and project name.
+ */
+export async function cleanTemplate({
+  targetFolder,
+  projectName,
+}: {
+  targetFolder: string;
+  projectName: string;
+}): Promise<void> {
+  // Change the current working directory to targetFolder if not already set
+  if (process.cwd() !== targetFolder) {
+    process.chdir(targetFolder);
+  }
+
+  return new Promise<void>(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 folderPath - The path of the folder to clean.
+ */
+export async function removeFolderContents(folderPath: string): Promise<void> {
+  // 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 pathToRemove - The path to the file or folder to remove.
+ */
+export async function removeFileOrFolder(pathToRemove: string): Promise<void> {
+  await fs.rm(pathToRemove, { recursive: true, force: true });
+}
+
+/**
+ * Helper function to copy files if the source exists.
+ * @param src - The source file path.
+ * @param dest - The destination file path.
+ */
+export async function copyFile(src: string, dest: string): Promise<void> {
+  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: any) {
+    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.ts

@@ -0,0 +1,15 @@
+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.
+ */
+export async function isEmptyDirectory(path: string): Promise<boolean> {
+  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.ts

@@ -0,0 +1,25 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+interface PackageJson {
+  name?: string;
+  version: string;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  [key: string]: unknown;
+}
+
+// Helper function to read and parse package.json
+async function readPackageJson(): Promise<PackageJson> {
+  const PACKAGE_JSON_FILE = resolve(
+    fileURLToPath(import.meta.url),
+    '../../../package.json'
+  );
+
+  const packageJsonContent = await readFile(PACKAGE_JSON_FILE, 'utf-8');
+  return JSON.parse(packageJsonContent) as PackageJson;
+}
+
+// Export the parsed package.json content
+export const packageJson: PackageJson = await readPackageJson();