create-nattyjs 0.0.1-beta.66 → 0.0.1-beta.67

package/index.js

@@ -1,316 +1,349 @@
-#!/usr/bin/env node
-import fs from 'fs'
-import path from 'path'
-import minimist from 'minimist'
-const argv = minimist(process.argv.slice(2), { string: ['_'] });
-import prompts from 'prompts'
-import {execa} from 'execa'
-import {fileURLToPath} from 'url';
-
-import {
-    yellow,
-    green,
-    blue,
-    red,
-    reset
-  } from 'kolorist';
-  import { bold } from 'kleur/colors';
-
-import chalk from 'chalk';
-import ora from 'ora';
-
-const gradients = [
-	`#00FF97`,
-	`#29FF8F`,
-	`#58FF38`,
-	`#3BFF24`,
-	`#93FF05`,
-	`#4EFF00`,
-	`#6FF500`,
-	`#14E684`,
-	`#36D629`,
-	`#38C266`,
-];
+#!/usr/bin/env node
+import fs from "fs";
+import path from "path";
+import minimist from "minimist";
+import prompts from "prompts";
+import { fileURLToPath } from "url";
+import { red, reset } from "kolorist";
 
-export const arrow = '■■▶';
+const argv = minimist(process.argv.slice(2), {
+    string: ["template"],
+    boolean: ["examples"],
+    alias: {
+        t: "template",
+        e: "examples",
+    },
+});
 
-const gradientRefrences = [
-	...gradients,
-	...[...gradients].reverse(),
-	...gradients,
-];
+const cwd = process.cwd();
 
+const renameFiles = {
+    _gitignore: ".gitignore",
+};
 
-const sleepProcess = (time) =>
-	new Promise((resolve) => {
-		setTimeout(resolve, time);
-	});
-
-function getInstallAnimationFrames() {
-	const animationFrames = [];
-	for (let i = 0; i < gradients.length * 2; i++) {
-		const end = i + gradients.length - 1;
-		animationFrames.push(
-			gradientRefrences
-				.slice(i, end)
-				.map((g) => chalk.bgHex(g)(' '))
-				.join('')
-		);
-	}
-	return animationFrames;
+const TEMPLATE_DEFINITIONS = [
+    {
+        id: "api-only",
+        aliases: ["nattyjs-blank"],
+        title: "API Only",
+        description: "Backend API (current blank template)",
+        templateDir: "template-nattyjs-blank",
+        exampleExcludedPaths: ["controllers"],
+    },
+    {
+        id: "fullstack-vue",
+        aliases: ["vue", "nattyjs-vue"],
+        title: "Fullstack + Vue",
+        description: "NattyJS API + Vue (Vite)",
+        templateDir: "template-fullstack-vue",
+        exampleOverlayDir: "__examples",
+    },
+    {
+        id: "fullstack-react",
+        aliases: ["react", "nattyjs-react"],
+        title: "Fullstack + React",
+        description: "NattyJS API + React (Vite)",
+        templateDir: "template-fullstack-react",
+        exampleOverlayDir: "__examples",
+    },
+    {
+        id: "fullstack-next",
+        aliases: ["next", "nextjs", "nattyjs-next"],
+        title: "Fullstack + Next.js",
+        description: "NattyJS API + Next.js",
+        templateDir: "template-fullstack-next",
+        exampleOverlayDir: "__examples",
+    },
+    {
+        id: "fullstack-nuxt",
+        aliases: ["nuxt", "nuxtjs", "nattyjs-nuxt"],
+        title: "Fullstack + Nuxt",
+        description: "NattyJS API + Nuxt",
+        templateDir: "template-fullstack-nuxt",
+        exampleOverlayDir: "__examples",
+    },
+    {
+        id: "fullstack-angular",
+        aliases: ["angular", "ng", "nattyjs-angular"],
+        title: "Fullstack + Angular",
+        description: "NattyJS API + Angular",
+        templateDir: "template-fullstack-angular",
+        exampleOverlayDir: "__examples",
+    },
+    {
+        id: "fullstack-astro",
+        aliases: ["astro", "nattyjs-astro"],
+        title: "Fullstack + Astro",
+        description: "NattyJS API + Astro",
+        templateDir: "template-fullstack-astro",
+        exampleOverlayDir: "__examples",
+    },
+    {
+        id: "fullstack-sveltekit",
+        aliases: ["sveltekit", "svelte-kit", "svelte", "nattyjs-sveltekit"],
+        title: "Fullstack + SvelteKit",
+        description: "NattyJS API + SvelteKit",
+        templateDir: "template-fullstack-sveltekit",
+        exampleOverlayDir: "__examples",
+    },
+];
+
+if (process.env.NATTYJS_PROMPT_INJECT) {
+    prompts.inject(JSON.parse(process.env.NATTYJS_PROMPT_INJECT));
 }
 
-function getAnimationFrames() {
-	const animationFrames = [];
-	for (let i = 1; i <= gradients.length; i++) {
-		const spaces = Array.from(
-			new Array(Math.abs(gradients.length - i - 1)),
-			() => ' '
-		);
-		const gradientColors = gradients.slice(0, i).map((item) => chalk.bgHex(item)(' '));
-		animationFrames.push([...spaces, ...gradientColors].join(''));
-	}
-	return animationFrames;
+function readJson(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return undefined;
+    }
+
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
 }
 
+function getTemplateById(value) {
+    if (!value) {
+        return undefined;
+    }
 
-async function showSpinner(text) {
-	const animationFrames = getAnimationFrames();
-	const startSpinner = ora({
-		spinner: {
-			interval: 30,
-			frames:animationFrames,
-		},
-		text: `${arrow} ${text}`,
-	});
-	startSpinner.start();
-	await sleepProcess((animationFrames.length - 1) * startSpinner.interval);
-	startSpinner.stop();
-	const spinner = ora({
-		spinner: {
-			interval: 80,
-			frames: getInstallAnimationFrames(),
-		},
-		text: `${arrow} ${text}`,
-	}).start();
-
-	return spinner;
+    return TEMPLATE_DEFINITIONS.find((template) => {
+        return template.id === value || template.aliases.includes(value);
+    });
 }
-  
-const cwd = process.cwd()
 
-const SCAFFOLDING_TEMPLATES = [
-  {
-    title:'Blank Project',
-    name: 'nattyjs-blank',
-    color: yellow
-  }
+function isValidPackageName(projectName) {
+    return /^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(projectName);
+}
 
-]
+function toValidPackageName(projectName) {
+    return projectName
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/g, "-")
+        .replace(/^[._]/, "")
+        .replace(/[^a-z0-9-~]+/g, "-");
+}
 
+function isEmpty(dirPath) {
+    const files = fs.readdirSync(dirPath);
+    return files.length === 0 || (files.length === 1 && files[0] === ".git");
+}
 
-  const renameFiles = {
-    _gitignore: '.gitignore'
-  }
+function emptyDir(dir) {
+    if (!fs.existsSync(dir)) {
+        return;
+    }
 
-function readFileSync(path,isString=false) {
-    if(fs.existsSync(path)){
-        var content = fs.readFileSync(path, "utf-8");
-        content = isString ? content: JSON.parse(content);
-        return content;
+    for (const file of fs.readdirSync(dir)) {
+        const absolutePath = path.resolve(dir, file);
+        if (fs.lstatSync(absolutePath).isDirectory()) {
+            emptyDir(absolutePath);
+            fs.rmdirSync(absolutePath);
+        } else {
+            fs.unlinkSync(absolutePath);
+        }
     }
 }
 
-  async function initNatty() {
-    let targetDir = argv._[0]
-    let template = argv.template || argv.t
-  
-    const defaultProjectName = !targetDir ? 'nattyjs-project' : targetDir
-  
-    let result = {}
-  
-    try {
-      result = await prompts(
-        [
-          {
-            type: targetDir ? null : 'text',
-            name: 'projectName',
-            message: reset('Project name:'),
-            initial: defaultProjectName,
-            onState: (state) =>
-              (targetDir = state.value.trim() || defaultProjectName)
-          },
-          {
-            type: () =>
-              !fs.existsSync(targetDir) || isEmpty(targetDir) ? null : 'confirm',
-            name: 'overwrite',
-            message: () =>
-              (targetDir === '.'
-                ? 'Current directory'
-                : `Target directory "${targetDir}"`) +
-              ` is not empty. Remove existing files and continue?`
-          },
-          {
-            type: (_, { overwrite } = {}) => {
-              if (overwrite === false) {
-                throw new Error(red('✖') + ' Operation cancelled')
-              }
-              return null
-            },
-            name: 'overwriteChecker'
-          },
-          {
-            type: () => (isValidPackageName(targetDir) ? null : 'text'),
-            name: 'packageName',
-            message: reset('Package name:'),
-            initial: () => toValidPackageName(targetDir),
-            validate: (dir) =>
-              isValidPackageName(dir) || 'Invalid package.json name'
-          },
-          {
-            type: 'select',
-            name: 'variant',
-            message: reset('Select a scaffolding template:'),
-            // @ts-ignore
-            choices: () =>
-              SCAFFOLDING_TEMPLATES.map((template) => {
-                const templateColor = template.color
-                return {
-                  title: templateColor(template.title),
-                  value: template.name
-                }
-              })
-          }
-        ],
-        {
-          onCancel: () => {
-            throw new Error(red('✖') + ' Operation cancelled')
-          }
-        }
-      )
-    } catch (cancelled) {
-      console.log(cancelled.message)
-      return
+function copy(src, dest) {
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+        copyDir(src, dest);
+        return;
     }
-  
-    const { framework, overwrite, packageName, variant } = result
-  
-    const root = path.join(cwd, targetDir)
-  
-    if (overwrite) {
-      emptyDir(root)
-    } else if (!fs.existsSync(root)) {
-      fs.mkdirSync(root)
+
+    fs.copyFileSync(src, dest);
+}
+
+function copyDir(srcDir, destDir) {
+    fs.mkdirSync(destDir, { recursive: true });
+    for (const file of fs.readdirSync(srcDir)) {
+        const srcFile = path.resolve(srcDir, file);
+        const destFile = path.resolve(destDir, file);
+        copy(srcFile, destFile);
     }
-    template = variant || framework || template
-  
-    console.log(`\nScaffolding project in ${root}...`)
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    const templateDir = path.join(__dirname, `template-${template}`)
-    const write = (file, content) => {
-      const targetPath = renameFiles[file]
-        ? path.join(root, renameFiles[file])
-        : path.join(root, file)
-      if (content) {
-        fs.writeFileSync(targetPath, content)
-      } else {
-        copy(path.join(templateDir, file), targetPath)
-      }
+}
+
+function pkgFromUserAgent(userAgent) {
+    if (!userAgent) {
+        return undefined;
     }
-  
-    const files = fs.readdirSync(templateDir)
-    for (const file of files.filter((f) => f !== 'package.json')) {
-      write(file)
+
+    const pkgSpec = userAgent.split(" ")[0];
+    const [name, version] = pkgSpec.split("/");
+    return { name, version };
+}
+
+function shouldSkipTemplateFile(relativePath, template, includeExamples) {
+    if (includeExamples) {
+        return false;
     }
-    const pkg = readFileSync(path.join(templateDir, `package.json`))
-  
-    pkg.name = packageName || targetDir
-  
-    write('package.json', JSON.stringify(pkg, null, 2))
-  
-    const pkgInfo = pkgFromUserAgent(process.env.npm_config_user_agent)
-    const pkgManager = pkgInfo ? pkgInfo.name : 'npm'
-    console.log(`\nDone. Now run:\n`)
-    if (root !== cwd) {
-      console.log(`  cd ${path.relative(cwd, root)}`)
+
+    const excludedPaths = template.exampleExcludedPaths || [];
+    return excludedPaths.some((excludedPath) => {
+        return relativePath === excludedPath || relativePath.startsWith(`${excludedPath}${path.sep}`);
+    });
+}
+
+function copyTemplateContents(templateDir, root, template, includeExamples) {
+    const entries = fs.readdirSync(templateDir);
+    for (const entry of entries) {
+        if (entry === "package.json") {
+            continue;
+        }
+
+        if (entry === template.exampleOverlayDir) {
+            continue;
+        }
+
+        if (shouldSkipTemplateFile(entry, template, includeExamples)) {
+            continue;
+        }
+
+        const sourcePath = path.join(templateDir, entry);
+        const targetPath = renameFiles[entry]
+            ? path.join(root, renameFiles[entry])
+            : path.join(root, entry);
+
+        copy(sourcePath, targetPath);
     }
-    switch (pkgManager) {
-      case 'yarn':
-        console.log('  yarn')
-        console.log('  yarn dev')
-        break
-      default:
-          console.log(`  ${pkgManager} install`)
-          console.log(`  ${pkgManager} run dev`)
-        break
+
+    if (includeExamples && template.exampleOverlayDir) {
+        const overlayDir = path.join(templateDir, template.exampleOverlayDir);
+        if (fs.existsSync(overlayDir)) {
+            copyDir(overlayDir, root);
+        }
     }
-    console.log()
-  }
-  
-  function copy(src, dest) {
-    const stat = fs.statSync(src)
-    if (stat.isDirectory()) {
-      copyDir(src, dest)
-    } else {
-      fs.copyFileSync(src, dest)
+}
+
+async function resolveProjectOptions() {
+    let targetDir = typeof argv._[0] === "string" ? argv._[0].trim() : "";
+    let selectedTemplate = getTemplateById(argv.template);
+    const defaultProjectName = targetDir || "nattyjs-project";
+
+    try {
+        return await prompts(
+            [
+                {
+                    type: targetDir ? null : "text",
+                    name: "projectName",
+                    message: reset("Project name:"),
+                    initial: defaultProjectName,
+                    validate: (value) => {
+                        const trimmed = value.trim();
+                        return trimmed.length > 0 || "Project name is required";
+                    },
+                    onState: (state) => {
+                        targetDir = state.value.trim() || defaultProjectName;
+                    },
+                },
+                {
+                    type: () => {
+                        return !targetDir || !fs.existsSync(targetDir) || isEmpty(targetDir) ? null : "confirm";
+                    },
+                    name: "overwrite",
+                    message: () => {
+                        const label = targetDir === "." ? "Current directory" : `Target directory "${targetDir}"`;
+                        return `${label} is not empty. Remove existing files and continue?`;
+                    },
+                    initial: false,
+                },
+                {
+                    type: (_, { overwrite } = {}) => {
+                        if (overwrite === false) {
+                            throw new Error(`${red("x")} Operation cancelled`);
+                        }
+                        return null;
+                    },
+                    name: "overwriteChecker",
+                },
+                {
+                    type: () => (isValidPackageName(path.basename(targetDir || defaultProjectName)) ? null : "text"),
+                    name: "packageName",
+                    message: reset("Package name:"),
+                    initial: () => toValidPackageName(path.basename(targetDir || defaultProjectName)),
+                    validate: (value) => isValidPackageName(value) || "Invalid package.json name",
+                },
+                {
+                    type: selectedTemplate ? null : "select",
+                    name: "templateId",
+                    message: reset("Select a template:"),
+                    choices: TEMPLATE_DEFINITIONS.map((template) => ({
+                        title: template.title,
+                        description: template.description,
+                        value: template.id,
+                    })),
+                },
+                {
+                    type: typeof argv.examples === "boolean" ? null : "toggle",
+                    name: "includeExamples",
+                    message: reset("Include examples?"),
+                    initial: true,
+                    active: "Yes",
+                    inactive: "No",
+                },
+            ],
+            {
+                onCancel: () => {
+                    throw new Error(`${red("x")} Operation cancelled`);
+                },
+            }
+        );
+    } catch (error) {
+        console.log(error.message);
+        return undefined;
     }
-  }
-  
-  function isValidPackageName(projectName) {
-    return /^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(
-      projectName
-    )
-  }
-  
-  function toValidPackageName(projectName) {
-    return projectName
-      .trim()
-      .toLowerCase()
-      .replace(/\s+/g, '-')
-      .replace(/^[._]/, '')
-      .replace(/[^a-z0-9-~]+/g, '-')
-  }
-  
-  function copyDir(srcDir, destDir) {
-    fs.mkdirSync(destDir, { recursive: true })
-    for (const file of fs.readdirSync(srcDir)) {
-      const srcFile = path.resolve(srcDir, file)
-      const destFile = path.resolve(destDir, file)
-      copy(srcFile, destFile)
+}
+
+async function initNatty() {
+    const promptResult = await resolveProjectOptions();
+    if (!promptResult) {
+        return;
     }
-  }
-  
-  function isEmpty(path) {
-    const files = fs.readdirSync(path)
-    return files.length === 0 || (files.length === 1 && files[0] === '.git')
-  }
-  
-  function emptyDir(dir) {
-    if (!fs.existsSync(dir)) {
-      return
+
+    const targetDir = (promptResult.projectName || argv._[0] || "").trim() || "nattyjs-project";
+    const template = getTemplateById(promptResult.templateId || argv.template) || TEMPLATE_DEFINITIONS[0];
+    const includeExamples = typeof argv.examples === "boolean" ? argv.examples : promptResult.includeExamples !== false;
+    const root = path.join(cwd, targetDir);
+
+    if (promptResult.overwrite) {
+        emptyDir(root);
+    } else if (!fs.existsSync(root)) {
+        fs.mkdirSync(root, { recursive: true });
     }
-    for (const file of fs.readdirSync(dir)) {
-      const abs = path.resolve(dir, file)
-      if (fs.lstatSync(abs).isDirectory()) {
-        emptyDir(abs)
-        fs.rmdirSync(abs)
-      } else {
-        fs.unlinkSync(abs)
-      }
+
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const templateDir = path.join(__dirname, template.templateDir);
+
+    console.log(`\nScaffolding project in ${root}...`);
+
+    copyTemplateContents(templateDir, root, template, includeExamples);
+
+    const packageJsonPath = path.join(templateDir, "package.json");
+    const pkg = readJson(packageJsonPath);
+    const packageName = promptResult.packageName || toValidPackageName(path.basename(targetDir));
+    pkg.name = packageName;
+    fs.writeFileSync(path.join(root, "package.json"), JSON.stringify(pkg, null, 2));
+
+    const pkgInfo = pkgFromUserAgent(process.env.npm_config_user_agent);
+    const pkgManager = pkgInfo ? pkgInfo.name : "npm";
+
+    console.log("\nDone. Now run:\n");
+    if (root !== cwd) {
+        console.log(`  cd ${path.relative(cwd, root)}`);
     }
-  }
-  
-  function pkgFromUserAgent(userAgent) {
-    if (!userAgent) return undefined
-    const pkgSpec = userAgent.split(' ')[0]
-    const pkgSpecArr = pkgSpec.split('/')
-    return {
-      name: pkgSpecArr[0],
-      version: pkgSpecArr[1]
+
+    if (pkgManager === "yarn") {
+        console.log("  yarn");
+        console.log("  yarn dev");
+    } else {
+        console.log(`  ${pkgManager} install`);
+        console.log(`  ${pkgManager} run dev`);
     }
-  }
 
-  initNatty().catch((e) => {
-    console.error(e)
-  })
+    console.log();
+}
+
+initNatty().catch((error) => {
+    console.error(error);
+});

package/package.json

@@ -1,12 +1,19 @@
 {
   "name": "create-nattyjs",
-  "version": "0.0.1-beta.66",
+  "version": "0.0.1-beta.67",
   "description": "Create NattyJS API Project",
   "main": "./index.js",
   "types": "./dist/index.d.ts",
   "type": "module",
   "files": [
-    "template-nattyjs-blank"
+    "template-nattyjs-blank",
+    "template-fullstack-vue",
+    "template-fullstack-react",
+    "template-fullstack-next",
+    "template-fullstack-nuxt",
+    "template-fullstack-angular",
+    "template-fullstack-astro",
+    "template-fullstack-sveltekit"
   ],
   "scripts": {
     "test": "echo \"No tests defined\""

package/template-fullstack-angular/__examples/apps/api/controllers/requests.controller.ts

@@ -0,0 +1,13 @@
+import { anonymous } from "@nattyjs/core"
+
+export class RequestsController {
+    @anonymous()
+    async get(): Promise<Array<{ name: string }>> {
+        return [{ name: "NattyJS" }, { name: "Angular" }]
+    }
+
+    @anonymous()
+    async getBy(id: number): Promise<{ name: string; id: number }> {
+        return { name: "NattyJS", id }
+    }
+}