create-sette-ts 1.0.0

package/README.md

@@ -0,0 +1,47 @@
+# create-sette-ts
+
+CLI para criar um projeto TypeScript novo com a estrutura deste repositório.
+
+## Uso local
+
+Enquanto estiver desenvolvendo o gerador, execute na raiz deste repositório:
+
+```powershell
+node .\bin\create-sette-ts.js meu-projeto
+```
+
+Para testar o pacote exatamente como ele será distribuído:
+
+```powershell
+npm pack
+npx .\create-sette-ts-1.0.0.tgz meu-projeto
+```
+
+O instalador cria a pasta, troca o nome no `package.json`, instala as dependências e mostra os próximos comandos.
+
+Opções disponíveis:
+
+- `--no-install`: cria os arquivos sem instalar dependências;
+- `--git`: executa `git init` no projeto criado;
+- `--help`: exibe a ajuda.
+
+## Publicação no npm
+
+Antes da primeira publicação, confirme se o nome `create-sette-ts` está disponível. Depois, autentique-se e publique:
+
+```powershell
+npm login
+npm publish
+```
+
+Após a publicação, qualquer pessoa poderá usar:
+
+```powershell
+npx create-sette-ts@latest meu-projeto
+```
+
+Ou, no formato `npm create`:
+
+```powershell
+npm create sette-ts@latest meu-projeto
+```

package/bin/create-sette-ts.js

@@ -0,0 +1,379 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import { constants } from "node:fs";
+import {
+  access,
+  cp,
+  mkdir,
+  readFile,
+  readdir,
+  rename,
+  rm,
+  writeFile,
+} from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+
+const templateDir = fileURLToPath(
+  new URL("../template", import.meta.url),
+);
+
+const colors = {
+  cyan: "\u001b[36m",
+  green: "\u001b[32m",
+  red: "\u001b[31m",
+  yellow: "\u001b[33m",
+  reset: "\u001b[0m",
+};
+
+function paint(color, message) {
+  return process.stdout.isTTY
+    ? `${colors[color]}${message}${colors.reset}`
+    : message;
+}
+
+function printHelp() {
+  console.log(`
+Uso:
+  create-sette-ts <nome-do-projeto> [opções]
+
+Opções:
+  --no-install   Não instala as dependências
+  --git          Inicializa um repositório Git
+  -h, --help     Exibe esta ajuda
+
+Exemplos:
+  npx create-sette-ts meu-projeto
+  npm create sette-ts@latest meu-projeto -- --git
+`);
+}
+
+function parseArgs(args) {
+  const options = {
+    install: true,
+    git: false,
+    help: false,
+    projectDir: undefined,
+  };
+
+  for (const arg of args) {
+    if (arg === "-h" || arg === "--help") {
+      options.help = true;
+    } else if (arg === "--no-install") {
+      options.install = false;
+    } else if (arg === "--git") {
+      options.git = true;
+    } else if (arg.startsWith("-")) {
+      throw new Error(`Opção desconhecida: ${arg}`);
+    } else if (!options.projectDir) {
+      options.projectDir = arg;
+    } else {
+      throw new Error(`Argumento inesperado: ${arg}`);
+    }
+  }
+
+  return options;
+}
+
+async function askProjectDir() {
+  if (!process.stdin.isTTY) {
+    throw new Error(
+      "Informe o nome do projeto. Exemplo: create-sette-ts meu-projeto",
+    );
+  }
+
+  const prompt = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    const answer = await prompt.question("Nome do projeto: ");
+    return answer.trim();
+  } finally {
+    prompt.close();
+  }
+}
+
+function getPackageName(projectDir) {
+  return path.basename(path.resolve(projectDir)).toLowerCase();
+}
+
+function validatePackageName(packageName) {
+  return (
+    Boolean(packageName) &&
+    packageName.length <= 214 &&
+    /^(?![._])[a-z0-9][a-z0-9._-]*$/.test(packageName)
+  );
+}
+
+async function pathExists(target) {
+  try {
+    await access(target);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+
+    throw error;
+  }
+}
+
+async function isEmpty(directory) {
+  try {
+    return (await readdir(directory)).length === 0;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return true;
+    }
+
+    throw error;
+  }
+}
+
+function detectPackageManager() {
+  const userAgent =
+    process.env.npm_config_user_agent ?? "npm";
+
+  const name = userAgent.split("/")[0];
+
+  return ["npm", "pnpm", "yarn", "bun"].includes(name)
+    ? name
+    : "npm";
+}
+
+function run(command, args, cwd) {
+  let result;
+
+  const requiresWindowsShell =
+    process.platform === "win32" &&
+    ["npm", "pnpm", "yarn"].includes(command);
+
+  if (requiresWindowsShell) {
+    /*
+     * npm, pnpm e yarn normalmente são .cmd no Windows.
+     * Chamamos cmd.exe explicitamente em vez de usar
+     * spawnSync(..., { shell: true }), evitando o DEP0190.
+     *
+     * Os comandos e argumentos passados para esta função
+     * são definidos internamente pelo CLI.
+     */
+    result = spawnSync(
+      process.env.ComSpec ?? "cmd.exe",
+      [
+        "/d",
+        "/s",
+        "/c",
+        `${command} ${args.join(" ")}`,
+      ],
+      {
+        cwd,
+        stdio: "inherit",
+      },
+    );
+  } else {
+    /*
+     * git e bun possuem executáveis que podem ser
+     * chamados diretamente no Windows.
+     *
+     * Linux/macOS também entram aqui.
+     */
+    result = spawnSync(command, args, {
+      cwd,
+      stdio: "inherit",
+    });
+  }
+
+  if (result.error) {
+    return false;
+  }
+
+  return result.status === 0;
+}
+
+async function createProject(options) {
+  const projectDir =
+    options.projectDir || (await askProjectDir());
+
+  if (!projectDir) {
+    throw new Error("O nome do projeto não pode ser vazio.");
+  }
+
+  const packageName = getPackageName(projectDir);
+
+  if (!validatePackageName(packageName)) {
+    throw new Error(
+      `"${packageName}" não é um nome de pacote npm válido.`,
+    );
+  }
+
+  const targetDir = path.resolve(
+    process.cwd(),
+    projectDir,
+  );
+
+  if (!(await isEmpty(targetDir))) {
+    throw new Error(
+      `A pasta ${targetDir} não está vazia.`,
+    );
+  }
+
+  const directoryAlreadyExisted =
+    await pathExists(targetDir);
+
+  /*
+   * Esta etapa é a criação propriamente dita.
+   *
+   * Se algo falhar enquanto copia/configura o template,
+   * fazemos rollback caso a pasta tenha sido criada
+   * pelo próprio CLI.
+   */
+  try {
+    await mkdir(targetDir, {
+      recursive: true,
+    });
+
+    await cp(templateDir, targetDir, {
+      recursive: true,
+    });
+
+    const packageJsonPath = path.join(
+      targetDir,
+      "package.json",
+    );
+
+    const packageJson = await readFile(
+      packageJsonPath,
+      "utf8",
+    );
+
+    await writeFile(
+      packageJsonPath,
+      packageJson.replaceAll(
+        "{{projectName}}",
+        packageName,
+      ),
+    );
+
+    await rename(
+      path.join(targetDir, "_gitignore"),
+      path.join(targetDir, ".gitignore"),
+    );
+  } catch (error) {
+    if (!directoryAlreadyExisted) {
+      await rm(targetDir, {
+        recursive: true,
+        force: true,
+      });
+    }
+
+    throw error;
+  }
+
+  const packageManager = detectPackageManager();
+
+  /*
+   * A partir daqui o projeto já está criado.
+   *
+   * Se npm install falhar por internet, registry,
+   * permissão etc., não faz sentido apagar tudo.
+   */
+  let installed = false;
+
+  if (options.install) {
+    console.log(
+      `\n${paint(
+        "cyan",
+        `Instalando dependências com ${packageManager}...`,
+      )}`,
+    );
+
+    installed = run(
+      packageManager,
+      ["install"],
+      targetDir,
+    );
+
+    if (!installed) {
+      console.warn(
+        `\n${paint(
+          "yellow",
+          "Aviso:",
+        )} não foi possível instalar as dependências.`,
+      );
+
+      console.warn(
+        `Execute manualmente: ${packageManager} install`,
+      );
+    }
+  }
+
+  if (options.git) {
+    console.log(
+      `\n${paint(
+        "cyan",
+        "Inicializando o Git...",
+      )}`,
+    );
+
+    if (!run("git", ["init"], targetDir)) {
+      console.warn(
+        `${paint(
+          "yellow",
+          "Aviso:",
+        )} não foi possível inicializar o Git.`,
+      );
+    }
+  }
+
+  const relativeDir =
+    path.relative(process.cwd(), targetDir) || ".";
+
+  console.log(
+    `\n${paint(
+      "green",
+      "Projeto criado com sucesso!",
+    )}\n`,
+  );
+
+  if (relativeDir !== ".") {
+    console.log(`  cd ${relativeDir}`);
+  }
+
+  if (!options.install || !installed) {
+    console.log(`  ${packageManager} install`);
+  }
+
+  console.log(
+    `  ${packageManager} run dev\n`,
+  );
+}
+
+try {
+  await access(templateDir, constants.R_OK);
+
+  const options = parseArgs(
+    process.argv.slice(2),
+  );
+
+  if (options.help) {
+    printHelp();
+  } else {
+    await createProject(options);
+  }
+} catch (error) {
+  const message =
+    error instanceof Error
+      ? error.message
+      : String(error);
+
+  console.error(
+    `\n${paint("red", "Erro:")} ${message}\n`,
+  );
+
+  process.exitCode = 1;
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "create-sette-ts",
+  "version": "1.0.0",
+  "description": "CLI para criar projetos TypeScript a partir do template sette-ts.",
+  "type": "module",
+  "bin": {
+    "create-sette-ts": "bin/create-sette-ts.js"
+  },
+  "files": [
+    "bin",
+    "template"
+  ],
+  "scripts": {
+    "test": "node --test --test-isolation=none test/create-project.test.js",
+    "test:cli": "node --test --test-isolation=none test/create-project.test.js"
+  },
+  "keywords": [
+    "cli",
+    "create-app",
+    "typescript",
+    "starter"
+  ],
+  "author": "Sette0o0",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/template/.env.example

@@ -0,0 +1 @@
+# Adicione aqui as variáveis de ambiente do projeto.

package/template/_gitignore

@@ -0,0 +1,6 @@
+node_modules/
+dist/
+
+.env
+.env.*
+!.env.example

package/template/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "{{projectName}}",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+    "dist": "node dist/index.js",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "dotenv": "^17.4.2"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.1",
+    "nodemon": "^3.1.14",
+    "tsc-alias": "^1.9.4",
+    "tsx": "^4.23.13",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.0"
+  }
+}

package/template/src/index.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { hello } from "@/index.js";
+
+describe("create-sette-ts", () => {
+  it('should log "Hello, World!"', () => {
+    const consoleSpy = vi
+      .spyOn(console, "log")
+      .mockImplementation(() => {});
+
+    hello();
+
+    expect(consoleSpy).toHaveBeenCalledExactlyOnceWith("Hello, World!");
+
+    consoleSpy.mockRestore();
+  });
+});

package/template/src/index.ts

@@ -0,0 +1,4 @@
+export function hello() {
+  console.log("Hello, World!");
+}
+hello()

package/template/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+  },
+  "include": ["src"],
+  "exclude": ["**/*.test.ts", "**/*.spec.ts"]
+}

package/template/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "module": "nodenext",
+    "target": "esnext",
+    "types": ["node"],
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "strict": true,
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  }
+}

package/template/vitest.config.ts

@@ -0,0 +1,13 @@
+import { fileURLToPath } from "node:url";
+import { config } from "dotenv";
+import { defineConfig } from "vitest/config";
+
+config({ path: ".test.env", override: true });
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      "@": fileURLToPath(new URL("./src", import.meta.url)),
+    },
+  },
+});