@auraindustry/aurajs 0.0.7 → 0.1.0

package/src/starter-content-registry.mjs

@@ -0,0 +1,292 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, relative, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import { loadMakeCatalog } from './make-catalog.mjs';
+
+export const STARTER_CONTENT_REGISTRY_SCHEMA = 'aurajs.starter-content-registry.v1';
+
+function normalizeProjectRelativePath(value) {
+  return String(value || '').split(/[/\\]+/g).filter(Boolean).join('/');
+}
+
+function toProjectRelativePath(projectRoot, absolutePath) {
+  return normalizeProjectRelativePath(relative(projectRoot, absolutePath));
+}
+
+function compareEntries(left, right) {
+  return left.id.localeCompare(right.id) || left.path.localeCompare(right.path);
+}
+
+function buildStarterContentEntry({ id, kind, path, exportName = 'default' }) {
+  return {
+    id: String(id || '').trim(),
+    kind: String(kind || '').trim(),
+    path: normalizeProjectRelativePath(path),
+    exportName: typeof exportName === 'string' && exportName.trim().length > 0 ? exportName.trim() : 'default',
+  };
+}
+
+function normalizeStarterContentRegistry(data, { template, family }) {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    throw new Error('Starter content registry must default-export an object.');
+  }
+  const normalizedEntries = Array.isArray(data.entries)
+    ? data.entries.map((entry, index) => {
+      if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+        throw new Error(`Starter content registry entry at index ${index} must be an object.`);
+      }
+      const id = String(entry.id || '').trim();
+      const kind = String(entry.kind || '').trim();
+      const path = String(entry.path || '').trim();
+      if (!id) {
+        throw new Error(`Starter content registry entry at index ${index} is missing id.`);
+      }
+      if (!kind) {
+        throw new Error(`Starter content registry entry "${id}" is missing kind.`);
+      }
+      if (!path) {
+        throw new Error(`Starter content registry entry "${id}" is missing path.`);
+      }
+      return buildStarterContentEntry({
+        id,
+        kind,
+        path,
+        exportName: entry.exportName,
+      });
+    })
+    : [];
+
+  normalizedEntries.sort(compareEntries);
+
+  return {
+    schema: typeof data.schema === 'string' && data.schema.trim().length > 0 ? data.schema.trim() : STARTER_CONTENT_REGISTRY_SCHEMA,
+    template: typeof data.template === 'string' && data.template.trim().length > 0 ? data.template.trim() : String(template || 'blank'),
+    family: typeof data.family === 'string' && data.family.trim().length > 0 ? data.family.trim() : String(family || ''),
+    title: typeof data.title === 'string' && data.title.trim().length > 0 ? data.title.trim() : null,
+    entries: normalizedEntries,
+  };
+}
+
+function serializeValue(value, indent = 0) {
+  return JSON.stringify(value, null, 2)
+    .split('\n')
+    .map((line, index) => (index === 0 ? line : `${' '.repeat(indent)}${line}`))
+    .join('\n');
+}
+
+export function renderStarterContentRegistryModule(model) {
+  const normalized = normalizeStarterContentRegistry(model, {
+    template: model?.template,
+    family: model?.family,
+  });
+  return `const starterContentRegistry = ${serializeValue({
+    schema: STARTER_CONTENT_REGISTRY_SCHEMA,
+    template: normalized.template,
+    family: normalized.family,
+    title: normalized.title,
+    entries: normalized.entries,
+  }, 0)};
+
+export function createStarterContentRegistry() {
+  return starterContentRegistry;
+}
+
+export default starterContentRegistry;
+`;
+}
+
+function resolveStarterContentFamilies(projectRoot, options = {}) {
+  const catalog = loadMakeCatalog({
+    projectRoot,
+    catalogRoot: options.catalogRoot,
+  });
+  const families = new Map();
+  for (const entry of catalog) {
+    if (!entry.starterContentFamily || !entry.starterContentRegistry) continue;
+    const key = `${entry.starterContentFamily}::${entry.starterContentRegistry}`;
+    if (!families.has(key)) {
+      families.set(key, {
+        family: entry.starterContentFamily,
+        registryPath: normalizeProjectRelativePath(entry.starterContentRegistry),
+        kinds: new Set(),
+      });
+    }
+    families.get(key).kinds.add(entry.id);
+  }
+  return [...families.values()].map((entry) => ({
+    family: entry.family,
+    registryPath: entry.registryPath,
+    kinds: [...entry.kinds].sort(),
+  }));
+}
+
+async function importRegistryModule(projectRoot, registryPath) {
+  const absolutePath = resolve(projectRoot, registryPath);
+  return import(`${pathToFileURL(absolutePath).href}?t=${Date.now()}-${Math.random().toString(16).slice(2)}`);
+}
+
+async function loadStarterContentRegistryFile({ projectRoot, family, registryPath }) {
+  const absolutePath = resolve(projectRoot, registryPath);
+  if (!existsSync(absolutePath)) {
+    return normalizeStarterContentRegistry({
+      schema: STARTER_CONTENT_REGISTRY_SCHEMA,
+      template: null,
+      family,
+      title: null,
+      entries: [],
+    }, { template: null, family });
+  }
+  const imported = await importRegistryModule(projectRoot, registryPath);
+  return normalizeStarterContentRegistry(imported.default, { template: null, family });
+}
+
+export async function listStarterContentRegistries({ projectRoot, catalogRoot = null }) {
+  const families = resolveStarterContentFamilies(resolve(projectRoot), { catalogRoot });
+  const results = [];
+  for (const spec of families) {
+    const registry = await loadStarterContentRegistryFile({
+      projectRoot,
+      family: spec.family,
+      registryPath: spec.registryPath,
+    });
+    results.push({
+      family: spec.family,
+      registryPath: spec.registryPath,
+      kinds: spec.kinds,
+      title: registry.title,
+      entries: registry.entries,
+      exists: existsSync(resolve(projectRoot, spec.registryPath)),
+    });
+  }
+  return results;
+}
+
+export async function registerGeneratedStarterContentFiles({ projectRoot, kindSpec, name, files }) {
+  if (!kindSpec?.starterContentFamily || !kindSpec?.starterContentRegistry) {
+    return {
+      changed: false,
+      registryPath: null,
+      files: [],
+      family: null,
+    };
+  }
+
+  const primaryFile = Array.isArray(files)
+    ? files.find((entry) => String(entry).endsWith('.js')) || files[0] || null
+    : null;
+  if (!primaryFile) {
+    return {
+      changed: false,
+      registryPath: null,
+      files: [],
+      family: null,
+    };
+  }
+
+  const normalizedProjectRoot = resolve(projectRoot);
+  const registryPath = normalizeProjectRelativePath(kindSpec.starterContentRegistry);
+  const absoluteRegistryPath = resolve(normalizedProjectRoot, registryPath);
+  const existing = await loadStarterContentRegistryFile({
+    projectRoot: normalizedProjectRoot,
+    family: kindSpec.starterContentFamily,
+    registryPath,
+  });
+  const entries = [...existing.entries];
+  const nextEntry = buildStarterContentEntry({
+    id: name,
+    kind: kindSpec.id || kindSpec.kind,
+    path: primaryFile,
+    exportName: 'default',
+  });
+  const index = entries.findIndex((entry) => entry.id === nextEntry.id);
+  if (index === -1) {
+    entries.push(nextEntry);
+  } else {
+    entries[index] = {
+      ...entries[index],
+      ...nextEntry,
+    };
+  }
+
+  const nextRegistry = normalizeStarterContentRegistry({
+    schema: STARTER_CONTENT_REGISTRY_SCHEMA,
+    template: existing.template,
+    family: kindSpec.starterContentFamily,
+    title: existing.title,
+    entries,
+  }, {
+    template: existing.template,
+    family: kindSpec.starterContentFamily,
+  });
+
+  mkdirSync(dirname(absoluteRegistryPath), { recursive: true });
+  writeFileSync(absoluteRegistryPath, renderStarterContentRegistryModule(nextRegistry), 'utf8');
+
+  return {
+    changed: true,
+    family: kindSpec.starterContentFamily,
+    registryPath,
+    files: [toProjectRelativePath(normalizedProjectRoot, absoluteRegistryPath)],
+  };
+}
+
+export async function validateStarterContentRegistries({ projectRoot, catalogRoot = null }) {
+  const registries = await listStarterContentRegistries({ projectRoot, catalogRoot });
+  const errors = [];
+
+  for (const registry of registries) {
+    if (!registry.exists) {
+      errors.push({
+        reasonCode: 'starter_content_registry_missing',
+        message: `Missing starter content registry: ${registry.registryPath}.`,
+        path: registry.registryPath,
+      });
+      continue;
+    }
+
+    const seen = new Set();
+    for (const entry of registry.entries) {
+      if (seen.has(entry.id)) {
+        errors.push({
+          reasonCode: 'starter_content_duplicate_id',
+          message: `Duplicate starter content id "${entry.id}" in ${registry.registryPath}.`,
+          path: registry.registryPath,
+        });
+        continue;
+      }
+      seen.add(entry.id);
+
+      const absolutePath = resolve(projectRoot, entry.path);
+      if (!existsSync(absolutePath)) {
+        errors.push({
+          reasonCode: 'starter_content_path_missing',
+          message: `Starter content path does not exist: ${entry.path}`,
+          path: entry.path,
+        });
+        continue;
+      }
+
+      try {
+        const imported = await import(`${pathToFileURL(absolutePath).href}?t=${Date.now()}-${Math.random().toString(16).slice(2)}`);
+        if (entry.exportName !== 'default' && typeof imported?.[entry.exportName] === 'undefined') {
+          throw new Error(`Missing export "${entry.exportName}".`);
+        }
+        if (entry.exportName === 'default' && typeof imported?.default === 'undefined') {
+          throw new Error('Missing default export.');
+        }
+      } catch (error) {
+        errors.push({
+          reasonCode: 'starter_content_import_broken',
+          message: `Unable to import ${entry.path}: ${error instanceof Error ? error.message : String(error)}`,
+          path: entry.path,
+        });
+      }
+    }
+  }
+
+  return {
+    registries,
+    errors,
+  };
+}