@sansavision/aurora 0.1.0-alpha.20260212.4

package/src/create-feature.ts

@@ -0,0 +1,419 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+import {
+  scaffoldRoute,
+  type RouteDataSource,
+  type RouteKind,
+} from "./create-route";
+import { type CommandContext, type CommandResult } from "./registry";
+
+const FEATURE_NAME_PLACEHOLDER = "__AURORA_FEATURE_NAME__";
+const FEATURE_SLUG_PLACEHOLDER = "__AURORA_FEATURE_SLUG__";
+const ROUTE_KINDS: readonly RouteKind[] = [
+  "crud",
+  "read-only",
+  "form",
+  "dashboard",
+  "empty",
+];
+const ROUTE_DATA_SOURCES: readonly RouteDataSource[] = ["database", "api", "none"];
+
+interface CreateFeatureOptions {
+  rawName: string;
+  featureSlug: string;
+  featureName: string;
+  routeEnabled: boolean;
+  routeKind: RouteKind;
+  routeDataSource: RouteDataSource;
+  routeAuth: string;
+  routeRealtime: boolean;
+}
+
+interface CreateFeatureReport {
+  mode: "create-feature";
+  cwd: string;
+  featureSlug: string;
+  featureName: string;
+  featureRoot: string;
+  createdFileCount: number;
+  routeEnabled: boolean;
+  routeKind: RouteKind;
+  routeDataSource: RouteDataSource;
+  routeAuth: string;
+  routeRealtime: boolean;
+  routeRoot?: string;
+  routeCreatedFileCount: number;
+}
+
+function parseCreateFeatureOptions(
+  args: ReadonlyArray<string>,
+): CreateFeatureOptions | CommandResult {
+  if (args.length === 0) {
+    return {
+      exitCode: 2,
+      stderr: "aurora create-feature: feature name is required",
+    };
+  }
+
+  const firstArg = args[0];
+  if (!firstArg || firstArg.startsWith("-")) {
+    return {
+      exitCode: 2,
+      stderr: "aurora create-feature: feature name must be provided before options",
+    };
+  }
+
+  const slug = toFeatureSlug(firstArg);
+  if (!slug) {
+    return {
+      exitCode: 2,
+      stderr:
+        "aurora create-feature: feature name must include at least one letter or number",
+    };
+  }
+
+  const options: CreateFeatureOptions = {
+    rawName: firstArg,
+    featureSlug: slug,
+    featureName: toFeatureName(slug),
+    routeEnabled: true,
+    routeKind: "form",
+    routeDataSource: "database",
+    routeAuth: "public",
+    routeRealtime: false,
+  };
+
+  for (let i = 1; i < args.length; i += 1) {
+    const arg = args[i];
+
+    if (arg === "--kind") {
+      const value = args[i + 1];
+      if (!value || !isRouteKind(value)) {
+        return {
+          exitCode: 2,
+          stderr:
+            `aurora create-feature: --kind requires one of ${ROUTE_KINDS.join("|")}`,
+        };
+      }
+
+      options.routeKind = value;
+      i += 1;
+      continue;
+    }
+
+    if (arg === "--data") {
+      const value = args[i + 1];
+      if (!value || !isRouteDataSource(value)) {
+        return {
+          exitCode: 2,
+          stderr:
+            `aurora create-feature: --data requires one of ${ROUTE_DATA_SOURCES.join("|")}`,
+        };
+      }
+
+      options.routeDataSource = value;
+      i += 1;
+      continue;
+    }
+
+    if (arg === "--auth") {
+      const value = args[i + 1];
+      if (!value) {
+        return {
+          exitCode: 2,
+          stderr:
+            "aurora create-feature: --auth requires 'public', 'user', 'admin', or 'permission:<name>'",
+        };
+      }
+
+      const parsedAuth = parseAuthMode(value);
+      if (!parsedAuth) {
+        return {
+          exitCode: 2,
+          stderr:
+            "aurora create-feature: --auth requires 'public', 'user', 'admin', or 'permission:<name>'",
+        };
+      }
+
+      options.routeAuth = parsedAuth;
+      i += 1;
+      continue;
+    }
+
+    if (arg === "--route") {
+      options.routeEnabled = true;
+      continue;
+    }
+
+    if (arg === "--no-route") {
+      options.routeEnabled = false;
+      continue;
+    }
+
+    if (arg === "--realtime") {
+      options.routeRealtime = true;
+      continue;
+    }
+
+    if (arg === "--no-realtime") {
+      options.routeRealtime = false;
+      continue;
+    }
+
+    return {
+      exitCode: 2,
+      stderr: `aurora create-feature: unknown option '${arg}'`,
+    };
+  }
+
+  return options;
+}
+
+function isRouteKind(value: string): value is RouteKind {
+  return ROUTE_KINDS.includes(value as RouteKind);
+}
+
+function isRouteDataSource(value: string): value is RouteDataSource {
+  return ROUTE_DATA_SOURCES.includes(value as RouteDataSource);
+}
+
+function parseAuthMode(value: string): string | undefined {
+  const normalized = value.trim();
+  if (normalized === "public" || normalized === "user" || normalized === "admin") {
+    return normalized;
+  }
+
+  if (/^permission:[a-z0-9:_-]+$/i.test(normalized)) {
+    return normalized;
+  }
+
+  return undefined;
+}
+
+function toFeatureSlug(rawName: string): string {
+  return rawName
+    .trim()
+    .replace(/[^a-zA-Z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .replace(/-+/g, "-")
+    .toLowerCase();
+}
+
+function toFeatureName(slug: string): string {
+  const pascal = slug
+    .split("-")
+    .filter((part) => part.length > 0)
+    .map((part) => part[0].toUpperCase() + part.slice(1))
+    .join("");
+
+  if (/^[A-Za-z_]/.test(pascal)) {
+    return pascal;
+  }
+
+  return `Feature${pascal}`;
+}
+
+function isNonEmptyDirectory(path: string): boolean {
+  if (!existsSync(path)) {
+    return false;
+  }
+
+  try {
+    return readdirSync(path).length > 0;
+  } catch {
+    return false;
+  }
+}
+
+function collectTemplateFiles(
+  templateRoot: string,
+  currentDirectory: string,
+  featureName: string,
+  featureSlug: string,
+): ReadonlyArray<{ path: string; content: string }> {
+  const files: Array<{ path: string; content: string }> = [];
+  const entries = readdirSync(currentDirectory, { withFileTypes: true }).sort((left, right) =>
+    left.name.localeCompare(right.name),
+  );
+
+  for (const entry of entries) {
+    const absolutePath = join(currentDirectory, entry.name);
+    if (entry.isDirectory()) {
+      files.push(
+        ...collectTemplateFiles(
+          templateRoot,
+          absolutePath,
+          featureName,
+          featureSlug,
+        ),
+      );
+      continue;
+    }
+
+    if (!entry.isFile()) {
+      continue;
+    }
+
+    const relativePath = absolutePath
+      .slice(templateRoot.length + 1)
+      .replaceAll("\\", "/");
+    const source = readFileSync(absolutePath, "utf8");
+    const withFeatureName = source.split(FEATURE_NAME_PLACEHOLDER).join(featureName);
+    const withFeatureSlug = withFeatureName
+      .split(FEATURE_SLUG_PLACEHOLDER)
+      .join(featureSlug);
+
+    files.push({
+      path: relativePath,
+      content: withFeatureSlug,
+    });
+  }
+
+  return files;
+}
+
+function loadFeatureSkeletonTemplate(
+  featureName: string,
+  featureSlug: string,
+): ReadonlyArray<{ path: string; content: string }> | CommandResult {
+  const templateRoot = resolve(import.meta.dir, "../templates/feature-skeleton");
+  if (!existsSync(templateRoot)) {
+    return {
+      exitCode: 1,
+      stderr: `aurora create-feature: missing template directory ${templateRoot}`,
+    };
+  }
+
+  return collectTemplateFiles(templateRoot, templateRoot, featureName, featureSlug);
+}
+
+function scaffoldFeature(
+  options: CreateFeatureOptions,
+  context: CommandContext,
+): CreateFeatureReport | CommandResult {
+  const featureRoot = resolve(context.cwd, "src/features", options.featureSlug);
+  if (isNonEmptyDirectory(featureRoot)) {
+    return {
+      exitCode: 2,
+      stderr: `aurora create-feature: target directory already exists and is not empty: ${featureRoot}`,
+    };
+  }
+
+  const templateFiles = loadFeatureSkeletonTemplate(
+    options.featureName,
+    options.featureSlug,
+  );
+  if ("exitCode" in templateFiles) {
+    return templateFiles;
+  }
+
+  const routeRoot = resolve(context.cwd, "src/routes", options.featureSlug);
+  if (options.routeEnabled && isNonEmptyDirectory(routeRoot)) {
+    return {
+      exitCode: 2,
+      stderr: `aurora create-feature: target directory already exists and is not empty: ${routeRoot}`,
+    };
+  }
+
+  try {
+    mkdirSync(featureRoot, { recursive: true });
+
+    for (const file of templateFiles) {
+      const absolutePath = join(featureRoot, file.path);
+      mkdirSync(dirname(absolutePath), { recursive: true });
+      writeFileSync(absolutePath, `${file.content}\n`, "utf8");
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      exitCode: 1,
+      stderr: `aurora create-feature: failed to scaffold feature at ${featureRoot}: ${message}`,
+    }; 
+  }
+
+  let routeCreatedFileCount = 0;
+  let finalRouteRoot: string | undefined;
+
+  if (options.routeEnabled) {
+    const routeReport = scaffoldRoute(
+      {
+        routeSlug: options.featureSlug,
+        routeName: options.featureName,
+        kind: options.routeKind,
+        dataSource: options.routeDataSource,
+        auth: options.routeAuth,
+        realtime: options.routeRealtime,
+      },
+      context,
+      { commandName: "aurora create-feature" },
+    );
+
+    if ("exitCode" in routeReport) {
+      return routeReport;
+    }
+
+    routeCreatedFileCount = routeReport.createdFileCount;
+    finalRouteRoot = routeReport.routeRoot;
+  }
+
+  return {
+    mode: "create-feature",
+    cwd: context.cwd,
+    featureSlug: options.featureSlug,
+    featureName: options.featureName,
+    featureRoot,
+    createdFileCount: templateFiles.length + routeCreatedFileCount,
+    routeEnabled: options.routeEnabled,
+    routeKind: options.routeKind,
+    routeDataSource: options.routeDataSource,
+    routeAuth: options.routeAuth,
+    routeRealtime: options.routeRealtime,
+    routeRoot: finalRouteRoot,
+    routeCreatedFileCount,
+  };
+}
+
+function renderCreateFeatureReport(report: CreateFeatureReport): string {
+  const lines = [
+    "aurora create-feature bootstrap",
+    `cwd: ${report.cwd}`,
+    `feature_slug: ${report.featureSlug}`,
+    `feature_name: ${report.featureName}`,
+    `feature_root: ${report.featureRoot}`,
+    `route_scaffold: ${report.routeEnabled ? "enabled" : "disabled"}`,
+    `route_kind: ${report.routeKind}`,
+    `route_data_source: ${report.routeDataSource}`,
+    `route_auth: ${report.routeAuth}`,
+    `route_realtime: ${report.routeRealtime ? "enabled" : "disabled"}`,
+  ];
+
+  if (report.routeRoot) {
+    lines.push(`route_root: ${report.routeRoot}`);
+    lines.push(`route_created_files: ${report.routeCreatedFileCount}`);
+  }
+
+  lines.push(`created_files: ${report.createdFileCount}`);
+
+  return lines.join("\n");
+}
+
+export function runCreateFeatureCommand(
+  args: ReadonlyArray<string>,
+  context: CommandContext,
+): CommandResult {
+  const options = parseCreateFeatureOptions(args);
+  if ("exitCode" in options) {
+    return options;
+  }
+
+  const report = scaffoldFeature(options, context);
+  if ("exitCode" in report) {
+    return report;
+  }
+
+  return {
+    exitCode: 0,
+    stdout: renderCreateFeatureReport(report),
+  };
+}