@auraindustry/aurajs 0.0.7 → 0.1.0

package/src/make.mjs

@@ -0,0 +1,197 @@
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import {
+  assertAuraProjectRoot,
+  inferPrefabRole,
+  normalizePrefabRole,
+  registerGeneratedProjectFiles,
+} from './project-registry.mjs';
+import { registerGeneratedStarterContentFiles } from './starter-content-registry.mjs';
+import {
+  loadMakeCatalog,
+  listCoreMakeKinds,
+  listMakeKinds as listResolvedMakeKinds,
+  resolveMakeKind,
+} from './make-catalog.mjs';
+
+export function listMakeKinds() {
+  return listCoreMakeKinds();
+}
+
+export function listProjectMakeKinds({ cwd = process.cwd(), catalogRoot = null } = {}) {
+  return listResolvedMakeKinds({ projectRoot: resolve(cwd), catalogRoot });
+}
+
+export function listProjectMakeCatalog({ cwd = process.cwd(), catalogRoot = null } = {}) {
+  const projectRoot = resolve(cwd);
+  assertAuraProjectRoot(projectRoot, '`aura make list` must run inside an AuraJS project root (missing aura.config.json).');
+  return loadMakeCatalog({ projectRoot, catalogRoot });
+}
+
+export async function generateProjectFiles({ cwd = process.cwd(), kind, name, role = null, catalogRoot = null }) {
+  const projectRoot = resolve(cwd);
+  assertAuraProjectRoot(projectRoot, '`aura make` must run inside an AuraJS project root (missing aura.config.json).');
+  const normalizedKind = String(kind || '').trim();
+  const resolvedKind = resolveMakeKind(normalizedKind, { projectRoot, catalogRoot });
+  if (!resolvedKind) {
+    throw new Error(`Unknown make kind "${kind}". Supported kinds: ${listProjectMakeKinds({ cwd: projectRoot, catalogRoot }).join(', ')}.`);
+  }
+
+  const normalizedName = normalizeMakeName(name);
+  const displayTitle = toDisplayTitle(normalizedName);
+  const manifest = readTemplateManifest(resolvedKind);
+  const registrationKind = manifest.registerAs || normalizedKind;
+  const prefabRole = registrationKind === 'prefab'
+    ? normalizePrefabRole(role, { fallback: manifest.defaultRole || inferPrefabRole(normalizedName) })
+    : null;
+  const replacements = {
+    MAKE_KIND: normalizedKind,
+    MAKE_NAME: normalizedName,
+    MAKE_TITLE: displayTitle,
+    MAKE_EXPORT_NAME: toExportName(normalizedName),
+    MAKE_ROLE: prefabRole || '',
+  };
+  const plannedFiles = planOutputFiles({
+    projectRoot,
+    manifest,
+    replacements,
+  });
+
+  const conflicts = plannedFiles
+    .filter((entry) => existsSync(entry.targetPath))
+    .map((entry) => entry.relativePath);
+  if (conflicts.length > 0) {
+    throw new Error(`Refusing to overwrite existing file(s): ${conflicts.join(', ')}.`);
+  }
+
+  for (const entry of plannedFiles) {
+    mkdirSync(dirname(entry.targetPath), { recursive: true });
+    writeFileSync(entry.targetPath, renderTokens(entry.templateContent, replacements), 'utf8');
+  }
+
+  const registration = await registerGeneratedProjectFiles({
+    projectRoot,
+    kind: registrationKind,
+    name: normalizedName,
+    role: prefabRole,
+    files: plannedFiles.map((entry) => entry.relativePath),
+  });
+  const starterContentRegistration = await registerGeneratedStarterContentFiles({
+    projectRoot,
+    kindSpec: manifest,
+    name: normalizedName,
+    files: plannedFiles.map((entry) => entry.relativePath),
+  });
+  const outputFiles = new Set(plannedFiles.map((entry) => entry.relativePath));
+  for (const file of Array.isArray(registration?.files) ? registration.files : []) {
+    outputFiles.add(file);
+  }
+  for (const file of Array.isArray(starterContentRegistration?.files) ? starterContentRegistration.files : []) {
+    outputFiles.add(file);
+  }
+
+  return {
+    kind: normalizedKind,
+    registrationKind,
+    name: normalizedName,
+    role: prefabRole,
+    title: displayTitle,
+    files: [...outputFiles],
+    registration,
+    starterContentRegistration,
+  };
+}
+
+function readTemplateManifest(kind) {
+  const entry = kind && typeof kind === 'object' ? kind : resolveMakeKind(kind);
+  if (!entry) {
+    throw new Error(`Invalid make template manifest for kind "${kind}".`);
+  }
+  const manifest = JSON.parse(readFileSync(entry.manifestPath, 'utf8'));
+  if (!manifest || typeof manifest.kind !== 'string' || !Array.isArray(manifest.files) || typeof manifest.outputRoot !== 'string') {
+    throw new Error(`Invalid make template manifest for kind "${entry.id}".`);
+  }
+  return {
+    ...manifest,
+    kind: entry.id,
+    outputRoot: entry.outputRoot || manifest.outputRoot,
+    manifestDir: dirname(entry.manifestPath),
+    owner: entry.owner,
+    scope: entry.scope,
+    registerAs: entry.registerAs,
+    defaultRole: entry.defaultRole,
+    starterContentFamily: entry.starterContentFamily,
+    starterContentRegistry: entry.starterContentRegistry,
+  };
+}
+
+function planOutputFiles({ projectRoot, manifest, replacements }) {
+  return manifest.files.map((templateRelativePath) => {
+    const sourcePath = join(manifest.manifestDir, templateRelativePath);
+    const sourceStat = statSync(sourcePath);
+    if (!sourceStat.isFile()) {
+      throw new Error(`Missing make template file: ${templateRelativePath}`);
+    }
+
+    const renderedRelative = renderTokens(
+      templateRelativePath.replace(/^files\//, ''),
+      replacements,
+    );
+    const targetPath = join(projectRoot, manifest.outputRoot, renderedRelative);
+    return {
+      sourcePath,
+      targetPath,
+      relativePath: relative(projectRoot, targetPath),
+      templateContent: readFileSync(sourcePath, 'utf8'),
+    };
+  });
+}
+
+function renderTokens(value, replacements) {
+  let rendered = String(value);
+  for (const [key, replacement] of Object.entries(replacements)) {
+    rendered = rendered.replaceAll(`{{${key}}}`, replacement);
+  }
+  return rendered;
+}
+
+function normalizeMakeName(name) {
+  const raw = String(name || '').trim();
+  if (!raw) {
+    throw new Error('Missing file name for `aura make`.');
+  }
+  if (/[\\/]/.test(raw)) {
+    throw new Error('`aura make` names must not contain path separators.');
+  }
+
+  const normalized = raw
+    .replace(/\.[A-Za-z0-9._-]+$/, '')
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+    .replace(/[_\s.]+/g, '-')
+    .replace(/[^A-Za-z0-9-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .toLowerCase();
+
+  if (!normalized) {
+    throw new Error(`Unable to derive a valid file name from "${name}".`);
+  }
+
+  return normalized;
+}
+
+function toDisplayTitle(name) {
+  const words = String(name || '')
+    .split(/[-_\s]+/)
+    .filter(Boolean);
+  if (words.length === 0) return 'New File';
+  return words.map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(' ');
+}
+
+function toExportName(name) {
+  return String(name || '')
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join('');
+}