gazan-init 0.1.0

package/src/prompts/index.js

@@ -0,0 +1,186 @@
+"use strict";
+
+const p = require("@clack/prompts");
+const fs = require("fs-extra");
+const path = require("path");
+const { EntityValidationError } = require("../parser/entity/errors");
+const { readEntityFile } = require("../parser/entity/parse");
+
+function onCancel() {
+  p.cancel("Operation cancelled.");
+  process.exit(1);
+}
+
+async function ask(fn, opts) {
+  const result = await fn(opts);
+  if (p.isCancel(result)) onCancel();
+  return result;
+}
+
+async function runPrompts(defaults = {}) {
+  p.intro("GAZAN — backend project initializer");
+
+  const projectName = await ask(p.text, {
+    message: "Project name",
+    placeholder: "my-app",
+    initialValue: defaults.projectName,
+    validate: (value) => {
+      if (!value) return "Project name is required";
+      if (!/^[a-z0-9][a-z0-9-_]*$/i.test(value)) return "Use letters, digits, - and _ only";
+    },
+  });
+
+  const moduleSystem = await ask(p.select, {
+    message: "Which module system do you want?",
+    options: [
+      { value: "cjs", label: "CommonJS (CJS)" },
+      { value: "mjs", label: "ES Modules (MJS)" },
+    ],
+  });
+
+  const language = await ask(p.select, {
+    message: "Which language do you want?",
+    options: [
+      { value: "js", label: "JavaScript" },
+      { value: "ts", label: "TypeScript" },
+    ],
+  });
+
+  const aliasesEnabled = await ask(p.confirm, {
+    message: "Do you want to enable module/path aliases? (e.g. @/services/x instead of ../../services/x)",
+    initialValue: true,
+  });
+
+  const databaseChoice = await ask(p.select, {
+    message: "Which database do you want?",
+    options: [
+      { value: "postgresql-prisma", label: "PostgreSQL + Prisma" },
+      { value: "mongodb-mongoose", label: "MongoDB + Mongoose" },
+      { value: "mongodb-native", label: "MongoDB + native mongosh/driver" },
+      { value: "none", label: "None" },
+    ],
+  });
+
+  const database = parseDatabaseChoice(databaseChoice);
+
+  const architecture = await ask(p.select, {
+    message: "Which architecture do you want?",
+    options: [
+      { value: "mvc", label: "MVC" },
+      { value: "hmvc", label: "HMVC" },
+    ],
+  });
+
+  const useSrc = await ask(p.confirm, {
+    message: "Use src/ directory?",
+    initialValue: true,
+  });
+
+  const socketIO = await ask(p.confirm, {
+    message: "Do you need Socket.IO?",
+    initialValue: false,
+  });
+
+  const bullMQ = await ask(p.confirm, {
+    message: "Do you need BullMQ workers?",
+    initialValue: false,
+  });
+
+  // BullMQ already requires Redis, so rate limiting rides on that connection for free. Only ask
+  // when it wouldn't otherwise exist, so a "Redis-only-for-rate-limiting" setup stays reachable.
+  let rateLimitStrategy = "memory";
+  if (!bullMQ) {
+    const useRedisForRateLimit = await ask(p.confirm, {
+      message: "Use Redis for rate limiting? (No = in-memory rate limiting)",
+      initialValue: false,
+    });
+    rateLimitStrategy = useRedisForRateLimit ? "redis" : "memory";
+  }
+
+  const authEnabled = await ask(p.confirm, {
+    message: "Do you need authentication?",
+    initialValue: false,
+  });
+
+  let authMethods = [];
+  if (authEnabled) {
+    authMethods = await ask(p.multiselect, {
+      message: "Which authentication methods?",
+      options: [
+        { value: "email-password", label: "Email/password" },
+        { value: "jwt", label: "JWT" },
+        { value: "oauth", label: "OAuth" },
+        { value: "refresh-token", label: "Refresh tokens" },
+      ],
+      required: false,
+    });
+  }
+
+  const hasEntityFile = await ask(p.confirm, {
+    message: "Do you have an entity.json file?",
+    initialValue: false,
+  });
+
+  let entityFile = null;
+  if (hasEntityFile) {
+    entityFile = await promptEntityPath(database.type);
+  }
+
+  p.outro("Configuration collected.");
+
+  return {
+    projectName,
+    moduleSystem,
+    language,
+    aliasesEnabled,
+    database,
+    architecture,
+    useSrc,
+    socketIO,
+    bullMQ,
+    rateLimitStrategy,
+    authentication: { enabled: authEnabled, methods: authMethods },
+    entityFile,
+  };
+}
+
+async function promptEntityPath(databaseType) {
+  for (;;) {
+    const candidate = await ask(p.text, {
+      message: "Enter entity.json path",
+      placeholder: "./entity.json",
+      validate: (value) => {
+        if (!value || !value.trim()) return "A path is required";
+      },
+    });
+
+    const absolute = path.resolve(candidate.trim());
+    if (!fs.existsSync(absolute)) {
+      p.log.error(`No file exists at: ${absolute}`);
+      continue;
+    }
+
+    try {
+      readEntityFile(absolute, { databaseType });
+      p.log.success(`entity.json is valid (${absolute})`);
+      return absolute;
+    } catch (error) {
+      if (error instanceof EntityValidationError) {
+        p.log.error(error.format());
+      } else {
+        p.log.error(error.message);
+      }
+      const retry = await ask(p.confirm, { message: "Try a different path?", initialValue: true });
+      if (!retry) return null;
+    }
+  }
+}
+
+function parseDatabaseChoice(choice) {
+  if (choice === "postgresql-prisma") return { type: "postgresql", orm: "prisma" };
+  if (choice === "mongodb-mongoose") return { type: "mongodb", orm: "mongoose" };
+  if (choice === "mongodb-native") return { type: "mongodb", orm: "native" };
+  return { type: "none", orm: null };
+}
+
+module.exports = { runPrompts };

package/src/utils/fsSafety.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const fs = require("fs-extra");
+
+// The only entries safe to ignore when deciding whether a directory is "empty enough" to
+// generate into without asking. Deliberately NOT a blanket dotfile exclusion — a pre-existing
+// .env (real secrets), .gitignore, or editor config must still trip the not-empty safety prompt,
+// since GeneratorEngine.createFile overwrites unconditionally once generation proceeds.
+const IGNORABLE_ENTRIES = new Set([".git", ".DS_Store"]);
+
+function isDirEmpty(dir) {
+  if (!fs.existsSync(dir)) return true;
+  const entries = fs.readdirSync(dir).filter((e) => !IGNORABLE_ENTRIES.has(e));
+  return entries.length === 0;
+}
+
+module.exports = { isDirEmpty };

package/src/utils/strings.js

@@ -0,0 +1,110 @@
+"use strict";
+
+function splitWords(input) {
+  return String(input)
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/[_\-\s]+/g, " ")
+    .trim()
+    .split(" ")
+    .filter(Boolean);
+}
+
+function toPascalCase(input) {
+  return splitWords(input)
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+    .join("");
+}
+
+function toCamelCase(input) {
+  const pascal = toPascalCase(input);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+function toKebabCase(input) {
+  return splitWords(input)
+    .map((w) => w.toLowerCase())
+    .join("-");
+}
+
+function toSnakeCase(input) {
+  return splitWords(input)
+    .map((w) => w.toLowerCase())
+    .join("_");
+}
+
+function toUpperSnakeCase(input) {
+  return toSnakeCase(input).toUpperCase();
+}
+
+const IRREGULAR_PLURALS = {
+  person: "people",
+  child: "children",
+  man: "men",
+  woman: "women",
+  tooth: "teeth",
+  foot: "feet",
+  mouse: "mice",
+  goose: "geese",
+};
+
+function pluralize(word) {
+  const lower = word.toLowerCase();
+  if (IRREGULAR_PLURALS[lower]) {
+    return matchCase(word, IRREGULAR_PLURALS[lower]);
+  }
+  if (/(s|x|z|ch|sh)$/i.test(word)) return `${word}es`;
+  if (/[^aeiou]y$/i.test(word)) return `${word.slice(0, -1)}ies`;
+  if (/fe?$/i.test(word) && !/(roof|belief|chef|chief)$/i.test(word)) {
+    return `${word.replace(/fe?$/i, "")}ves`;
+  }
+  return `${word}s`;
+}
+
+function matchCase(source, target) {
+  if (source[0] === source[0].toUpperCase()) {
+    return target.charAt(0).toUpperCase() + target.slice(1);
+  }
+  return target;
+}
+
+/** Levenshtein edit distance, used to power "did you mean X?" suggestions in error messages. */
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, (_, i) => [i, ...new Array(n).fill(0)]);
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+    }
+  }
+  return dp[m][n];
+}
+
+/** Finds the closest match to `target` among `candidates`, or null if nothing is close enough to be useful. */
+function didYouMean(target, candidates) {
+  if (!target || candidates.length === 0) return null;
+  let best = null;
+  let bestDistance = Infinity;
+  for (const candidate of candidates) {
+    const distance = levenshtein(target.toLowerCase(), candidate.toLowerCase());
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      best = candidate;
+    }
+  }
+  const threshold = Math.max(2, Math.ceil(target.length / 2));
+  return bestDistance <= threshold ? best : null;
+}
+
+module.exports = {
+  toPascalCase,
+  toCamelCase,
+  toKebabCase,
+  toSnakeCase,
+  toUpperSnakeCase,
+  pluralize,
+  levenshtein,
+  didYouMean,
+};