@projectdochelp/s3te 1.0.0

package/packages/cli/bin/s3te.mjs

@@ -0,0 +1,383 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import {
+  deployProject,
+  doctorProject,
+  loadResolvedConfig,
+  migrateProject,
+  packageProject,
+  renderProject,
+  runProjectTests,
+  scaffoldProject,
+  validateProject
+} from "../src/project.mjs";
+
+function setOption(options, key, value) {
+  if (options[key] === undefined) {
+    options[key] = value;
+    return;
+  }
+
+  if (Array.isArray(options[key])) {
+    options[key].push(value);
+    return;
+  }
+
+  options[key] = [options[key], value];
+}
+
+function parseArgs(argv) {
+  const [command = "help", ...rest] = argv;
+  const options = { _: [] };
+  for (let index = 0; index < rest.length; index += 1) {
+    const token = rest[index];
+    if (!token.startsWith("--")) {
+      options._.push(token);
+      continue;
+    }
+
+    const key = token.slice(2);
+    const next = rest[index + 1];
+    if (!next || next.startsWith("--")) {
+      setOption(options, key, true);
+      continue;
+    }
+
+    setOption(options, key, next);
+    index += 1;
+  }
+  return { command, options };
+}
+
+function asArray(value) {
+  if (value === undefined) {
+    return [];
+  }
+  return Array.isArray(value) ? value : [value];
+}
+
+function duration(startTime) {
+  return Date.now() - startTime;
+}
+
+function printJson(command, success, warnings, errors, startedAt, data = undefined) {
+  process.stdout.write(JSON.stringify({
+    command,
+    success,
+    durationMs: duration(startedAt),
+    warnings,
+    errors,
+    data
+  }, null, 2) + "\n");
+}
+
+function printHelp() {
+  process.stdout.write(
+    "Usage: s3te <command> [options]\n\n" +
+    "Commands:\n" +
+    "  init\n" +
+    "  validate\n" +
+    "  render\n" +
+    "  test\n" +
+    "  package\n" +
+    "  deploy\n" +
+    "  doctor\n" +
+    "  migrate\n"
+  );
+}
+
+async function loadConfigForCommand(projectDir, configOption) {
+  const configPath = path.resolve(projectDir, configOption ?? "s3te.config.json");
+  return { configPath, ...(await loadResolvedConfig(projectDir, configPath)) };
+}
+
+function warningsShouldFail(options, warnings) {
+  return Boolean(options["warnings-as-errors"]) && warnings.length > 0;
+}
+
+async function main() {
+  const startedAt = Date.now();
+  const { command, options } = parseArgs(process.argv.slice(2));
+  const cwd = path.resolve(options.cwd ?? process.cwd());
+  const wantsJson = Boolean(options.json);
+
+  if (command === "help" || command === "--help" || command === "-h") {
+    printHelp();
+    return;
+  }
+
+  if (command === "init") {
+    const projectDir = path.resolve(cwd, options.dir ?? ".");
+    const result = await scaffoldProject(projectDir, {
+      projectName: options["project-name"],
+      baseUrl: options["base-url"],
+      variant: asArray(options.variant)[0],
+      language: asArray(options.lang)[0],
+      force: Boolean(options.force)
+    });
+
+    if (wantsJson) {
+      printJson("init", true, [], [], startedAt, result);
+      return;
+    }
+
+    process.stdout.write(`Initialized project ${result.projectName} in ${projectDir}\n`);
+    return;
+  }
+
+  if (command === "validate") {
+    const loaded = await loadConfigForCommand(cwd, options.config);
+    if (!loaded.ok) {
+      if (wantsJson) {
+        printJson("validate", false, loaded.warnings, loaded.errors, startedAt);
+      } else {
+        for (const error of loaded.errors) {
+          process.stderr.write(`${error.code}: ${error.message}\n`);
+        }
+      }
+      process.exitCode = 2;
+      return;
+    }
+
+    const validation = await validateProject(cwd, loaded.config, {
+      environment: asArray(options.env)[0]
+    });
+    const success = validation.ok && !warningsShouldFail(options, validation.warnings);
+
+    if (wantsJson) {
+      printJson("validate", success, validation.warnings, validation.errors, startedAt, {
+        configPath: loaded.configPath,
+        checkedEnvironments: asArray(options.env).length > 0 ? asArray(options.env) : Object.keys(loaded.config.environments),
+        checkedTemplates: validation.checkedTemplates
+      });
+      process.exitCode = success ? 0 : 2;
+      return;
+    }
+
+    if (!success) {
+      for (const error of validation.errors) {
+        process.stderr.write(`${error.code}: ${error.message}\n`);
+      }
+      if (warningsShouldFail(options, validation.warnings)) {
+        for (const warning of validation.warnings) {
+          process.stderr.write(`${warning.code}: ${warning.message}\n`);
+        }
+      }
+      process.exitCode = 2;
+      return;
+    }
+
+    process.stdout.write(`Config and templates valid: ${loaded.configPath}\n`);
+    return;
+  }
+
+  if (command === "render") {
+    const loaded = await loadConfigForCommand(cwd, options.config);
+    if (!loaded.ok) {
+      if (wantsJson) {
+        printJson("render", false, loaded.warnings, loaded.errors, startedAt);
+      } else {
+        for (const error of loaded.errors) {
+          process.stderr.write(`${error.code}: ${error.message}\n`);
+        }
+      }
+      process.exitCode = 2;
+      return;
+    }
+
+    if (!options.env) {
+      process.stderr.write("render requires --env <name>\n");
+      process.exitCode = 1;
+      return;
+    }
+
+    const report = await renderProject(cwd, loaded.config, {
+      environment: asArray(options.env)[0],
+      variant: asArray(options.variant)[0],
+      language: asArray(options.lang)[0],
+      entry: options.entry,
+      outputDir: options["output-dir"]
+    });
+    const success = !warningsShouldFail(options, report.warnings);
+
+    if (options.stdout && report.renderedArtifacts.length === 1) {
+      const body = await fs.readFile(path.join(cwd, report.renderedArtifacts[0]), "utf8");
+      process.stdout.write(body);
+      process.exitCode = success ? 0 : 2;
+      return;
+    }
+
+    if (wantsJson) {
+      printJson("render", success, report.warnings, [], startedAt, report);
+      process.exitCode = success ? 0 : 2;
+      return;
+    }
+
+    process.stdout.write(`Rendered ${report.renderedArtifacts.length} artifact(s) into ${report.outputDir}\n`);
+    process.exitCode = success ? 0 : 2;
+    return;
+  }
+
+  if (command === "test") {
+    const loaded = await loadConfigForCommand(cwd, options.config);
+    if (!loaded.ok) {
+      if (wantsJson) {
+        printJson("test", false, loaded.warnings, loaded.errors, startedAt);
+      } else {
+        for (const error of loaded.errors) {
+          process.stderr.write(`${error.code}: ${error.message}\n`);
+        }
+      }
+      process.exitCode = 2;
+      return;
+    }
+
+    const validation = await validateProject(cwd, loaded.config, {
+      environment: asArray(options.env)[0]
+    });
+    if (!validation.ok) {
+      if (wantsJson) {
+        printJson("test", false, validation.warnings, validation.errors, startedAt);
+      }
+      process.exitCode = 2;
+      return;
+    }
+
+    const exitCode = await runProjectTests(cwd);
+    process.exitCode = exitCode;
+    return;
+  }
+
+  if (command === "package") {
+    const loaded = await loadConfigForCommand(cwd, options.config);
+    if (!loaded.ok) {
+      if (wantsJson) {
+        printJson("package", false, loaded.warnings, loaded.errors, startedAt);
+      }
+      process.exitCode = 2;
+      return;
+    }
+    if (!options.env) {
+      process.stderr.write("package requires --env <name>\n");
+      process.exitCode = 1;
+      return;
+    }
+
+    const report = await packageProject(cwd, loaded.config, {
+      environment: asArray(options.env)[0],
+      outDir: options["out-dir"],
+      clean: Boolean(options.clean),
+      features: asArray(options.feature)
+    });
+
+    if (wantsJson) {
+      printJson("package", true, [], [], startedAt, report);
+      return;
+    }
+
+    process.stdout.write(`Packaged deployment artifacts into ${report.packageDir}\n`);
+    return;
+  }
+
+  if (command === "deploy") {
+    const loaded = await loadConfigForCommand(cwd, options.config);
+    if (!loaded.ok) {
+      if (wantsJson) {
+        printJson("deploy", false, loaded.warnings, loaded.errors, startedAt);
+      }
+      process.exitCode = 2;
+      return;
+    }
+    if (!options.env) {
+      process.stderr.write("deploy requires --env <name>\n");
+      process.exitCode = 1;
+      return;
+    }
+
+    const report = await deployProject(cwd, loaded.config, {
+      environment: asArray(options.env)[0],
+      packageDir: options["package-dir"],
+      features: asArray(options.feature),
+      profile: options.profile,
+      plan: Boolean(options.plan),
+      noSync: Boolean(options["no-sync"]),
+      stdio: wantsJson ? "pipe" : "inherit"
+    });
+
+    if (wantsJson) {
+      printJson("deploy", true, [], [], startedAt, report);
+      return;
+    }
+
+    process.stdout.write(`${options.plan ? "Prepared" : "Deployed"} stack ${report.stackName}\n`);
+    return;
+  }
+
+  if (command === "doctor") {
+    let loaded = null;
+    try {
+      loaded = await loadConfigForCommand(cwd, options.config);
+    } catch {
+      loaded = null;
+    }
+
+    const configPath = path.resolve(cwd, options.config ?? "s3te.config.json");
+    const checks = await doctorProject(cwd, configPath, {
+      environment: asArray(options.env)[0],
+      config: loaded?.config,
+      profile: options.profile
+    });
+    const success = checks.every((check) => check.ok);
+
+    if (wantsJson) {
+      printJson("doctor", success, [], [], startedAt, { checks });
+      process.exitCode = success ? 0 : 3;
+      return;
+    }
+
+    for (const check of checks) {
+      process.stdout.write(`${check.ok ? "OK" : "FAIL"} ${check.name}: ${check.message}\n`);
+    }
+    process.exitCode = success ? 0 : 3;
+    return;
+  }
+
+  if (command === "migrate") {
+    const configPath = path.resolve(cwd, options.config ?? "s3te.config.json");
+    const rawConfig = JSON.parse(await fs.readFile(configPath, "utf8"));
+    const migration = await migrateProject(configPath, rawConfig, {
+      writeChanges: Boolean(options.write) && !Boolean(options["dry-run"]),
+      enableWebiny: Boolean(options["enable-webiny"]),
+      disableWebiny: Boolean(options["disable-webiny"]),
+      webinySourceTable: options["webiny-source-table"],
+      webinyTenant: options["webiny-tenant"],
+      webinyModels: asArray(options["webiny-model"])
+    });
+    if (wantsJson) {
+      printJson("migrate", true, [], [], startedAt, {
+        configVersion: migration.config.configVersion,
+        wrote: Boolean(options.write) && !Boolean(options["dry-run"]),
+        changes: migration.changes
+      });
+      return;
+    }
+    process.stdout.write(options.write ? `Migrated ${configPath}\n` : `Migration preview for ${configPath}: configVersion=${migration.config.configVersion}\n`);
+    for (const change of migration.changes) {
+      process.stdout.write(`- ${change}\n`);
+    }
+    return;
+  }
+
+  printHelp();
+  process.exitCode = 1;
+}
+
+main().catch((error) => {
+  process.stderr.write(`${error.code ?? "ERROR"}: ${error.message}\n`);
+  if (error.details) {
+    process.stderr.write(`${JSON.stringify(error.details, null, 2)}\n`);
+  }
+  process.exitCode = error.code === "CONFIG_SCHEMA_ERROR" || error.code === "CONFIG_CONFLICT_ERROR" || error.code === "TEMPLATE_SYNTAX_ERROR" ? 2 : 1;
+});

package/packages/cli/src/fs-adapters.mjs

@@ -0,0 +1,221 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { applyContentQuery, getContentTypeForPath } from "../../core/src/index.mjs";
+
+function normalizeKey(value) {
+  return String(value).replace(/\\/g, "/");
+}
+
+function normalizeLocale(value) {
+  return String(value).trim().toLowerCase();
+}
+
+function buildLocaleCandidates(language, languageLocaleMap) {
+  const requested = String(language ?? "").trim();
+  const configured = String(languageLocaleMap?.[requested] ?? requested).trim();
+  return [...new Set([configured, requested].filter(Boolean).map(normalizeLocale))];
+}
+
+function matchesRequestedLocale(item, language, languageLocaleMap) {
+  return localeMatchScore(item?.locale, language, languageLocaleMap) > 0;
+}
+
+function localeMatchScore(itemLocale, language, languageLocaleMap) {
+  if (!itemLocale) {
+    return 1;
+  }
+
+  const normalizedItemLocale = normalizeLocale(itemLocale);
+  const candidates = buildLocaleCandidates(language, languageLocaleMap);
+  if (candidates.includes(normalizedItemLocale)) {
+    return 3;
+  }
+
+  if (candidates.some((candidate) => candidate.length >= 2 && normalizedItemLocale.startsWith(`${candidate}-`))) {
+    return 2;
+  }
+
+  return 0;
+}
+
+function filterItemsByRequestedLocale(items, language, languageLocaleMap) {
+  const grouped = new Map();
+
+  for (const item of items) {
+    const groupKey = item.contentId ?? item.id ?? JSON.stringify(item);
+    if (!grouped.has(groupKey)) {
+      grouped.set(groupKey, []);
+    }
+    grouped.get(groupKey).push(item);
+  }
+
+  return [...grouped.values()].flatMap((groupItems) => {
+    const scored = groupItems
+      .map((item) => ({ item, score: localeMatchScore(item.locale, language, languageLocaleMap) }))
+      .filter((entry) => entry.score > 0);
+    if (scored.length === 0) {
+      return [];
+    }
+
+    const bestScore = Math.max(...scored.map((entry) => entry.score));
+    return scored.filter((entry) => entry.score === bestScore).map((entry) => entry.item);
+  });
+}
+
+async function walkFiles(rootDir, currentDir = rootDir) {
+  const entries = await fs.readdir(currentDir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await walkFiles(rootDir, fullPath));
+    } else if (entry.isFile()) {
+      files.push(path.relative(rootDir, fullPath).replace(/\\/g, "/"));
+    }
+  }
+  return files;
+}
+
+export class FileSystemTemplateRepository {
+  constructor(projectDir, config) {
+    this.projectDir = projectDir;
+    this.config = config;
+  }
+
+  resolveKey(key) {
+    const normalized = normalizeKey(key);
+
+    for (const [variantName, variantConfig] of Object.entries(this.config.variants)) {
+      if (normalized === variantName || normalized.startsWith(`${variantName}/`)) {
+        const suffix = normalized === variantName ? "" : normalized.slice(variantName.length + 1);
+        return path.join(this.projectDir, variantConfig.sourceDir, suffix);
+      }
+    }
+
+    return path.join(this.projectDir, normalized);
+  }
+
+  async get(key) {
+    const filePath = this.resolveKey(key);
+    try {
+      const body = await fs.readFile(filePath);
+      return {
+        key: normalizeKey(key),
+        body: body.toString("utf8"),
+        contentType: getContentTypeForPath(filePath)
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  async listVariantEntries(variant) {
+    const variantConfig = this.config.variants[variant];
+    const sourceDir = path.join(this.projectDir, variantConfig.sourceDir);
+    const files = await walkFiles(sourceDir);
+    return files.map((relativePath) => ({
+      key: `${variant}/${relativePath}`.replace(/\\/g, "/"),
+      body: null,
+      contentType: getContentTypeForPath(relativePath)
+    }));
+  }
+
+  async exists(key) {
+    try {
+      await fs.stat(this.resolveKey(key));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+export class FileSystemContentRepository {
+  constructor(itemsByLanguage, languageLocaleMap = {}) {
+    this.itemsByLanguage = itemsByLanguage;
+    this.languageLocaleMap = languageLocaleMap;
+  }
+
+  getItems(language) {
+    const items = this.itemsByLanguage[language] ?? this.itemsByLanguage.default ?? [];
+    return filterItemsByRequestedLocale(items, language, this.languageLocaleMap);
+  }
+
+  async getByContentId(contentId, language) {
+    return this.getItems(language).find((item) => item.contentId === contentId) ?? null;
+  }
+
+  async query(query, language) {
+    return applyContentQuery(this.getItems(language), query);
+  }
+}
+
+export async function loadLocalContent(projectDir, config) {
+  const contentDirectories = [
+    path.join(projectDir, "offline", "content"),
+    path.join(projectDir, "content")
+  ];
+  const itemsByLanguage = {};
+
+  try {
+    for (const contentDir of contentDirectories) {
+      let entries = [];
+      try {
+        entries = await fs.readdir(contentDir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+
+      for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".json")) {
+          continue;
+        }
+        const raw = await fs.readFile(path.join(contentDir, entry.name), "utf8");
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+          continue;
+        }
+        const key = entry.name === "items.json" ? "default" : entry.name.slice(0, -".json".length);
+        itemsByLanguage[key] = parsed;
+      }
+
+      if (Object.keys(itemsByLanguage).length > 0) {
+        break;
+      }
+    }
+  } catch {
+    for (const variantConfig of Object.values(config.variants)) {
+      for (const languageCode of Object.keys(variantConfig.languages)) {
+        itemsByLanguage[languageCode] = [];
+      }
+    }
+  }
+
+  const languageLocaleMap = Object.fromEntries(Object.entries(config.variants).flatMap(([, variantConfig]) => (
+    Object.entries(variantConfig.languages).map(([languageCode, languageConfig]) => [
+      languageCode,
+      languageConfig.webinyLocale ?? languageCode
+    ])
+  )));
+
+  return new FileSystemContentRepository(itemsByLanguage, languageLocaleMap);
+}
+
+export async function ensureDirectory(targetDir) {
+  await fs.mkdir(targetDir, { recursive: true });
+}
+
+export async function writeTextFile(targetPath, body) {
+  await ensureDirectory(path.dirname(targetPath));
+  await fs.writeFile(targetPath, body, "utf8");
+}
+
+export async function copyFile(sourcePath, targetPath) {
+  await ensureDirectory(path.dirname(targetPath));
+  await fs.copyFile(sourcePath, targetPath);
+}
+
+export async function removeDirectory(targetDir) {
+  await fs.rm(targetDir, { recursive: true, force: true });
+}