create-web-0to1 0.1.0

package/internal/engine/create-feature-script.ts

@@ -0,0 +1,142 @@
+import {
+  standaloneFeaturePresetConfigs,
+  type StandaloneFeaturePreset,
+} from './standalone-feature-preset.ts';
+
+const createFeatureScriptTemplate = `#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+
+const rootDir = process.cwd();
+const srcDir = path.join(rootDir, 'src');
+const __ROUTE_ROOT_CONST__ = path.join(srcDir, '__ROUTE_ROOT_NAME__');
+const featuresDir = path.join(srcDir, 'features');
+
+const rawName = process.argv[2];
+
+if (!rawName) {
+  console.error('사용법: npm run create:feature -- <feature-name>');
+  process.exit(1);
+}
+
+if (!/^[a-z][a-z0-9-]*$/.test(rawName)) {
+  console.error('feature 이름은 영문 소문자 kebab-case 형식이어야 하며 문자로 시작해야 합니다.');
+  process.exit(1);
+}
+
+function toPascalCase(value) {
+  return value
+    .split('-')
+    .filter(Boolean)
+    .map((part) => part[0].toUpperCase() + part.slice(1))
+    .join('');
+}
+
+function ensureDir(dirPath) {
+  if (fs.existsSync(dirPath)) {
+    console.log(\`skip: \${path.relative(rootDir, dirPath)}\`);
+    return;
+  }
+
+  fs.mkdirSync(dirPath, { recursive: true });
+  console.log(\`create: \${path.relative(rootDir, dirPath)}\`);
+}
+
+function ensureFile(filePath, content) {
+  if (fs.existsSync(filePath)) {
+    console.log(\`skip: \${path.relative(rootDir, filePath)}\`);
+    return;
+  }
+
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content, 'utf8');
+  console.log(\`create: \${path.relative(rootDir, filePath)}\`);
+}
+
+function getStyleMode() {
+  const packageJsonPath = path.join(rootDir, 'package.json');
+
+  if (!fs.existsSync(packageJsonPath)) {
+    return 'tailwind';
+  }
+
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    return packageJson['__PACKAGE_JSON_KEY__']?.style === 'none' ? 'none' : 'tailwind';
+  } catch {
+    return 'tailwind';
+  }
+}
+
+function getRoutePageContent(featureName, featureNamePascal, useStyles) {
+  if (!useStyles) {
+    return \`export default function \${featureNamePascal}Page() {
+  return (
+    <main>
+      <div>
+        <p>\${featureNamePascal}</p>
+        <h1>\${featureNamePascal}</h1>
+        <p>이 페이지를 실제 \${featureName} 도메인 화면으로 교체하세요.</p>
+      </div>
+    </main>
+  );
+}
+\`;
+  }
+
+  return \`export default function \${featureNamePascal}Page() {
+  return (
+    <main className="mx-auto flex min-h-screen w-full max-w-5xl flex-col gap-6 px-6 py-16">
+      <div>
+        <p className="text-sm font-medium uppercase tracking-[0.2em] text-zinc-500">\${featureNamePascal}</p>
+        <h1 className="mt-3 text-3xl font-semibold tracking-tight text-zinc-950">
+          \${featureNamePascal}
+        </h1>
+        <p className="mt-3 text-sm leading-6 text-zinc-600">
+          이 페이지를 실제 \${featureName} 도메인 화면으로 교체하세요.
+        </p>
+      </div>
+    </main>
+  );
+}
+\`;
+}
+
+const featureName = rawName;
+const featureNamePascal = toPascalCase(featureName);
+const featureDir = path.join(featuresDir, featureName);
+const routeDir = path.join(__ROUTE_ROOT_CONST__, featureName);
+const featurePath = \`/\${featureName}\`;
+const useStyles = getStyleMode() !== 'none';
+
+ensureDir(path.join(featureDir, 'api'));
+ensureDir(path.join(featureDir, 'components'));
+ensureDir(path.join(featureDir, 'hooks'));
+ensureDir(path.join(featureDir, 'lib'));
+
+ensureFile(
+  path.join(routeDir, 'page.tsx'),
+  getRoutePageContent(featureName, featureNamePascal, useStyles),
+);
+
+console.log('');
+console.log(\`"\${featureName}" feature 최소 스캐폴드 생성이 완료되었습니다.\`);
+console.log('생성 대상: api/, components/, hooks/, lib/, __ROUTE_OUTPUT_LABEL__');
+console.log('CRUD 예제가 필요하면 npm run create:feature:crud -- <feature-name> 을 사용하세요.');
+__OPTIONAL_ROUTE_HINT__console.log(\`중앙 route 상수가 필요하면 src/shared/routes/route-paths.ts에 직접 추가하세요:\`);
+console.log(\`  \${featureName}: '\${featurePath}',\`);
+`;
+
+export function buildStandaloneCreateFeatureScript(
+  preset: StandaloneFeaturePreset,
+) {
+  const config = standaloneFeaturePresetConfigs[preset];
+
+  // 실제 출력 스크립트는 preset별로 완결된 한 파일이 되도록 여기서 치환합니다.
+  return createFeatureScriptTemplate
+    .replaceAll('__ROUTE_ROOT_CONST__', config.routeRootConst)
+    .replaceAll('__ROUTE_ROOT_NAME__', config.routeRootName)
+    .replaceAll('__PACKAGE_JSON_KEY__', config.packageJsonKey)
+    .replaceAll('__ROUTE_OUTPUT_LABEL__', config.routeOutputLabel)
+    .replaceAll('__OPTIONAL_ROUTE_HINT__', config.optionalRouteHint);
+}

package/internal/engine/generator-engine.ts

@@ -0,0 +1,546 @@
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import * as posixPath from 'node:path/posix';
+
+import { buildStandaloneCreateFeatureCrudScript } from './create-feature-crud-script.ts';
+import { buildStandaloneCreateFeatureScript } from './create-feature-script.ts';
+import { getPresetPlan, type PresetPlan } from '../meta/preset-plan.ts';
+import {
+  createRuntimeCopyPlan,
+  rewriteRuntimeImports,
+  type RuntimeCopyEntry,
+} from '../meta/runtime-copy-plan.ts';
+import type { PresetId } from '../meta/scaffold-manifest.ts';
+
+export type ProjectFileCopyKind = 'template' | 'runtime';
+
+export type ProjectFileCopy = {
+  kind: ProjectFileCopyKind;
+  sourceRelativePath: string;
+  sourceAbsolutePath: string;
+  targetRelativePath: string;
+  targetAbsolutePath: string;
+};
+
+export type ProjectGenerationPlan = {
+  preset: PresetId;
+  targetDir: string;
+  templateDir: string;
+  removePaths: string[];
+  templateFiles: ProjectFileCopy[];
+  runtimeFiles: Array<ProjectFileCopy & { runtimeEntry: RuntimeCopyEntry }>;
+  notes: string[];
+};
+
+export type ExecuteProjectGenerationPlanOptions = {
+  plan: ProjectGenerationPlan;
+  dryRun?: boolean;
+};
+
+export type ExecuteProjectGenerationPlanResult = {
+  removedPaths: string[];
+  copiedTemplateFiles: string[];
+  copiedRuntimeFiles: string[];
+  dryRun: boolean;
+};
+
+type BuildProjectGenerationPlanOptions = {
+  workspaceRoot: string;
+  targetDir: string;
+  preset: PresetId;
+};
+
+function toPosixPath(value: string) {
+  return value.replaceAll(path.sep, '/');
+}
+
+function toSystemPath(rootDir: string, relativePosixPath: string) {
+  return path.join(rootDir, ...relativePosixPath.split('/'));
+}
+
+function resolveTemplateTargetRelativePath(relativeFilePath: string) {
+  const dirName = posixPath.dirname(relativeFilePath);
+  const baseName = posixPath.basename(relativeFilePath);
+  const mappedBaseName =
+    baseName === '_gitignore'
+      ? '.gitignore'
+      : baseName === '_npmrc'
+        ? '.npmrc'
+        : baseName;
+
+  if (dirName === '.') {
+    return mappedBaseName;
+  }
+
+  return posixPath.join(dirName, mappedBaseName);
+}
+
+async function listRelativeFiles(rootDir: string) {
+  const collected: string[] = [];
+
+  async function walk(currentDir: string) {
+    const entries = await fs.readdir(currentDir, {
+      withFileTypes: true,
+    });
+
+    for (const entry of entries) {
+      const absolutePath = path.join(currentDir, entry.name);
+
+      if (entry.isDirectory()) {
+        await walk(absolutePath);
+        continue;
+      }
+
+      if (!entry.isFile()) {
+        continue;
+      }
+
+      collected.push(toPosixPath(path.relative(rootDir, absolutePath)));
+    }
+  }
+
+  await walk(rootDir);
+
+  return collected.sort((left, right) => left.localeCompare(right));
+}
+
+function findDuplicateTargetPaths(fileCopies: ProjectFileCopy[]) {
+  const seen = new Set<string>();
+  const duplicates = new Set<string>();
+
+  for (const fileCopy of fileCopies) {
+    if (seen.has(fileCopy.targetRelativePath)) {
+      duplicates.add(fileCopy.targetRelativePath);
+      continue;
+    }
+
+    seen.add(fileCopy.targetRelativePath);
+  }
+
+  return [...duplicates].sort((left, right) => left.localeCompare(right));
+}
+
+async function buildTemplateFileCopies(
+  templateDir: string,
+  targetDir: string,
+) {
+  const relativeFiles = await listRelativeFiles(templateDir);
+
+  return relativeFiles.map((relativeFilePath) => ({
+    kind: 'template' as const,
+    sourceRelativePath: relativeFilePath,
+    sourceAbsolutePath: toSystemPath(templateDir, relativeFilePath),
+    targetRelativePath: resolveTemplateTargetRelativePath(relativeFilePath),
+    targetAbsolutePath: toSystemPath(
+      targetDir,
+      resolveTemplateTargetRelativePath(relativeFilePath),
+    ),
+  }));
+}
+
+async function buildRuntimeFileCopies(
+  workspaceRoot: string,
+  presetPlan: PresetPlan,
+  targetDir: string,
+) {
+  const sourceRoot = path.join(workspaceRoot, 'source');
+  const runtimeSourceFiles = new Set<string>();
+
+  for (const mapping of presetPlan.runtime.mappings) {
+    const sourceDir = toSystemPath(sourceRoot, mapping.sourceDir);
+    const relativeFiles = await listRelativeFiles(sourceDir);
+
+    for (const relativeFilePath of relativeFiles) {
+      runtimeSourceFiles.add(posixPath.join(mapping.sourceDir, relativeFilePath));
+    }
+  }
+
+  const runtimeCopyEntries = createRuntimeCopyPlan(
+    presetPlan.preset,
+    [...runtimeSourceFiles],
+  );
+
+  return runtimeCopyEntries.map((runtimeEntry) => ({
+    kind: 'runtime' as const,
+    sourceRelativePath: runtimeEntry.sourcePath,
+    sourceAbsolutePath: toSystemPath(sourceRoot, runtimeEntry.sourcePath),
+    targetRelativePath: runtimeEntry.outputPath,
+    targetAbsolutePath: toSystemPath(targetDir, runtimeEntry.outputPath),
+    runtimeEntry,
+  }));
+}
+
+export async function buildProjectGenerationPlan({
+  workspaceRoot,
+  targetDir,
+  preset,
+}: BuildProjectGenerationPlanOptions): Promise<ProjectGenerationPlan> {
+  const presetPlan = getPresetPlan(preset);
+  const templateDir = path.join(workspaceRoot, presetPlan.templateDir);
+  const templateFiles = await buildTemplateFileCopies(templateDir, targetDir);
+  const runtimeFiles = await buildRuntimeFileCopies(
+    workspaceRoot,
+    presetPlan,
+    targetDir,
+  );
+  const duplicateTargetPaths = findDuplicateTargetPaths([
+    ...templateFiles,
+    ...runtimeFiles,
+  ]);
+
+  if (duplicateTargetPaths.length > 0) {
+    throw new Error(
+      `Duplicate generation targets detected for preset "${preset}": ${duplicateTargetPaths.join(
+        ', ',
+      )}`,
+    );
+  }
+
+  return {
+    preset,
+    targetDir,
+    templateDir,
+    removePaths: presetPlan.scaffold.removeAfterScaffold,
+    templateFiles,
+    runtimeFiles,
+    notes: [
+      ...presetPlan.notes,
+      'templateFiles는 정적 override 파일입니다.',
+      'runtimeFiles는 source/ 기반 runtime source of truth입니다.',
+    ],
+  };
+}
+
+async function ensureParentDir(filePath: string) {
+  await fs.mkdir(path.dirname(filePath), {
+    recursive: true,
+  });
+}
+
+async function removeTargetPaths(
+  targetDir: string,
+  relativePaths: string[],
+  dryRun: boolean,
+) {
+  const removedPaths: string[] = [];
+
+  for (const relativePath of relativePaths) {
+    const absolutePath = toSystemPath(targetDir, relativePath);
+    removedPaths.push(relativePath);
+
+    if (dryRun) {
+      continue;
+    }
+
+    await fs.rm(absolutePath, {
+      recursive: true,
+      force: true,
+    });
+  }
+
+  return removedPaths;
+}
+
+function getFallbackProjectPackageName(targetAbsolutePath: string) {
+  const projectDirName = path.basename(path.dirname(targetAbsolutePath));
+
+  return (
+    projectDirName
+      .trim()
+      .toLowerCase()
+      .replaceAll(/[^a-z0-9._-]+/g, '-')
+      .replaceAll(/^[._-]+|[._-]+$/g, '') || 'app'
+  );
+}
+
+async function readJsonIfExists(filePath: string) {
+  try {
+    const text = await fs.readFile(filePath, 'utf8');
+
+    return JSON.parse(text) as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+}
+
+async function buildTemplateFileContents(
+  workspaceRoot: string,
+  preset: PresetId,
+  fileCopy: ProjectFileCopy,
+) {
+  if (
+    (preset === 'react' || preset === 'next') &&
+    fileCopy.targetRelativePath === 'scripts/create-feature-crud.mjs'
+  ) {
+    return buildStandaloneCreateFeatureCrudScript(preset, workspaceRoot);
+  }
+
+  if (
+    (preset === 'react' || preset === 'next') &&
+    fileCopy.targetRelativePath === 'scripts/create-feature.mjs'
+  ) {
+    return buildStandaloneCreateFeatureScript(preset);
+  }
+
+  if (
+    (preset === 'react' || preset === 'next') &&
+    fileCopy.targetRelativePath === 'package.json'
+  ) {
+    const templatePackageJson = (await readJsonIfExists(
+      fileCopy.sourceAbsolutePath,
+    )) ?? {};
+    const existingPackageJson = await readJsonIfExists(fileCopy.targetAbsolutePath);
+    const mergedPackageJson = {
+      ...(existingPackageJson ?? {}),
+      ...templatePackageJson,
+    } as Record<string, unknown>;
+
+    // Standalone preset은 upstream scaffold가 먼저 package.json을 만들기 때문에
+    // 앱 이름과 기본 dependency는 upstream 값을 유지하고,
+    // 템플릿은 scripts/metadata만 얹는 쪽으로 merge합니다.
+    mergedPackageJson.name =
+      typeof existingPackageJson?.name === 'string'
+        ? existingPackageJson.name
+        : getFallbackProjectPackageName(fileCopy.targetAbsolutePath);
+    mergedPackageJson.version =
+      typeof existingPackageJson?.version === 'string'
+        ? existingPackageJson.version
+        : templatePackageJson.version ?? '0.1.0';
+    mergedPackageJson.private = true;
+
+    if (typeof existingPackageJson?.packageManager === 'string') {
+      mergedPackageJson.packageManager = existingPackageJson.packageManager;
+    }
+
+    delete mergedPackageJson.bin;
+    delete mergedPackageJson.files;
+
+    return `${JSON.stringify(mergedPackageJson, null, 2)}\n`;
+  }
+
+  return null;
+}
+
+async function copyTemplateFiles(
+  workspaceRoot: string,
+  preset: PresetId,
+  fileCopies: ProjectFileCopy[],
+  dryRun: boolean,
+) {
+  const copiedFiles: string[] = [];
+
+  for (const fileCopy of fileCopies) {
+    copiedFiles.push(fileCopy.targetRelativePath);
+
+    if (dryRun) {
+      continue;
+    }
+
+    await ensureParentDir(fileCopy.targetAbsolutePath);
+    const fileContents = await buildTemplateFileContents(
+      workspaceRoot,
+      preset,
+      fileCopy,
+    );
+
+    if (fileContents === null) {
+      await fs.copyFile(fileCopy.sourceAbsolutePath, fileCopy.targetAbsolutePath);
+      continue;
+    }
+
+    await fs.writeFile(fileCopy.targetAbsolutePath, fileContents, 'utf8');
+  }
+
+  return copiedFiles;
+}
+
+function escapeRegExp(value: string) {
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function stripImportFromModule(sourceText: string, moduleSpecifier: string) {
+  const escapedSpecifier = escapeRegExp(moduleSpecifier);
+
+  return sourceText.replace(
+    new RegExp(
+      `import\\s*\\{[\\s\\S]*?\\}\\s*from\\s*['"]${escapedSpecifier}['"];\\n?`,
+      'm',
+    ),
+    '',
+  );
+}
+
+function stripTypeReExportBlock(sourceText: string) {
+  return sourceText.replace(/export type\s*\{[\s\S]*?\};\n\n?/m, '');
+}
+
+function splitLeadingImports(sourceText: string) {
+  const match = sourceText.match(/^(?:import[\s\S]*?;\n\s*)+/);
+
+  if (!match) {
+    return {
+      imports: '',
+      body: sourceText.trim(),
+    };
+  }
+
+  return {
+    imports: match[0].trim(),
+    body: sourceText.slice(match[0].length).trim(),
+  };
+}
+
+function renameStandaloneRequestCoreEntryPoint(sourceText: string) {
+  return sourceText.replace(
+    /export async function executeRequest\s*</,
+    'async function executeSharedRequest<',
+  );
+}
+
+function buildStandaloneMergedRequestText(coreText: string, wrapperText: string) {
+  const mergedCoreText = renameStandaloneRequestCoreEntryPoint(coreText).trim();
+  const mergedWrapperText = stripTypeReExportBlock(
+    stripImportFromModule(wrapperText, './request-core'),
+  ).trim();
+
+  return `${mergedCoreText}\n\n${mergedWrapperText}\n`;
+}
+
+function renameMonorepoRequestCoreTypes(sourceText: string) {
+  return sourceText.replaceAll(/\bRequestOptions\b/g, 'BaseRequestOptions');
+}
+
+function buildMonorepoMergedRequestText(coreText: string, wrapperText: string) {
+  const mergedCoreText = renameMonorepoRequestCoreTypes(
+    renameStandaloneRequestCoreEntryPoint(coreText),
+  ).trim();
+  const normalizedWrapperText = stripTypeReExportBlock(
+    stripImportFromModule(wrapperText, './request-core'),
+  )
+    .replaceAll('SharedRequestOptions', 'BaseRequestOptions')
+    .trim();
+  const { imports, body } = splitLeadingImports(normalizedWrapperText);
+
+  return `${imports}\n\n${mergedCoreText}\n\n${body}\n`;
+}
+
+function applyRuntimeOutputCompositions(
+  preset: PresetId,
+  sourceTextByTargetPath: Map<string, string>,
+) {
+  const nextSourceTextByTargetPath = new Map(sourceTextByTargetPath);
+  const skippedTargetPaths = new Set<string>();
+
+  if (preset === 'react' || preset === 'next') {
+    const requestCoreTargetPath = 'src/shared/api/request-core.ts';
+    const requestTargetPath = 'src/shared/api/request.ts';
+    const requestCoreText = nextSourceTextByTargetPath.get(requestCoreTargetPath);
+    const requestText = nextSourceTextByTargetPath.get(requestTargetPath);
+
+    if (requestCoreText && requestText) {
+      nextSourceTextByTargetPath.set(
+        requestTargetPath,
+        buildStandaloneMergedRequestText(requestCoreText, requestText),
+      );
+      skippedTargetPaths.add(requestCoreTargetPath);
+    }
+  }
+
+  if (preset === 'monorepo') {
+    const requestCoreTargetPath = 'packages/core/src/request/request-core.ts';
+    const requestTargetPath = 'packages/core/src/request/core-request.ts';
+    const requestCoreText = nextSourceTextByTargetPath.get(requestCoreTargetPath);
+    const requestText = nextSourceTextByTargetPath.get(requestTargetPath);
+
+    if (requestCoreText && requestText) {
+      nextSourceTextByTargetPath.set(
+        requestTargetPath,
+        buildMonorepoMergedRequestText(requestCoreText, requestText),
+      );
+      skippedTargetPaths.add(requestCoreTargetPath);
+    }
+  }
+
+  return {
+    sourceTextByTargetPath: nextSourceTextByTargetPath,
+    skippedTargetPaths,
+  };
+}
+
+async function copyRuntimeFiles(
+  preset: PresetId,
+  runtimeFiles: Array<ProjectFileCopy & { runtimeEntry: RuntimeCopyEntry }>,
+  dryRun: boolean,
+) {
+  const copiedFiles: string[] = [];
+  const availableSourceFiles = runtimeFiles.map((runtimeFile) => runtimeFile.sourceRelativePath);
+  const rewrittenSourceTextByTargetPath = new Map<string, string>();
+
+  for (const runtimeFile of runtimeFiles) {
+    const sourceText = await fs.readFile(runtimeFile.sourceAbsolutePath, 'utf8');
+    const rewrittenSourceText = rewriteRuntimeImports({
+      preset,
+      sourcePath: runtimeFile.sourceRelativePath,
+      sourceText,
+      availableSourceFiles,
+    });
+
+    rewrittenSourceTextByTargetPath.set(
+      runtimeFile.targetRelativePath,
+      rewrittenSourceText,
+    );
+  }
+
+  const { sourceTextByTargetPath, skippedTargetPaths } = applyRuntimeOutputCompositions(
+    preset,
+    rewrittenSourceTextByTargetPath,
+  );
+
+  for (const runtimeFile of runtimeFiles) {
+    if (skippedTargetPaths.has(runtimeFile.targetRelativePath)) {
+      continue;
+    }
+
+    copiedFiles.push(runtimeFile.targetRelativePath);
+
+    if (dryRun) {
+      continue;
+    }
+
+    const rewrittenSourceText = sourceTextByTargetPath.get(
+      runtimeFile.targetRelativePath,
+    );
+
+    if (!rewrittenSourceText) {
+      throw new Error(
+        `Missing rewritten runtime source for "${runtimeFile.targetRelativePath}"`,
+      );
+    }
+
+    await ensureParentDir(runtimeFile.targetAbsolutePath);
+    await fs.writeFile(runtimeFile.targetAbsolutePath, rewrittenSourceText, 'utf8');
+  }
+
+  return copiedFiles;
+}
+
+export async function executeProjectGenerationPlan({
+  plan,
+  dryRun = false,
+}: ExecuteProjectGenerationPlanOptions): Promise<ExecuteProjectGenerationPlanResult> {
+  const removedPaths = await removeTargetPaths(plan.targetDir, plan.removePaths, dryRun);
+  const copiedTemplateFiles = await copyTemplateFiles(
+    path.dirname(path.dirname(plan.templateDir)),
+    plan.preset,
+    plan.templateFiles,
+    dryRun,
+  );
+  const copiedRuntimeFiles = await copyRuntimeFiles(plan.preset, plan.runtimeFiles, dryRun);
+
+  return {
+    removedPaths,
+    copiedTemplateFiles,
+    copiedRuntimeFiles,
+    dryRun,
+  };
+}