hbs-magic 0.1.0

package/src/file-helpers.ts

@@ -0,0 +1,108 @@
+import fs from "fs";
+import fetch from "node-fetch";
+import https from "https";
+import path from "path";
+import { pathToFileURL } from "url";
+import { build } from "esbuild";
+import { HbsPartial } from "./hbs-process-helpers.js";
+
+const agent = new https.Agent({ rejectUnauthorized: false });
+
+export async function getJson(source: string) {
+  if (source.startsWith("http://") || source.startsWith("https://")) {
+    let response;
+    try {
+      response = await fetch(source, { agent });
+    } catch (err) {
+      throw new Error(`Failed to fetch JSON from URL: ${err}`);
+    }
+
+    if (!response.ok) throw new Error(`HTTP error: ${response.status}`);
+    return await response.json();
+  } else {
+    return JSON.parse(fs.readFileSync(source, "utf8"));
+  }
+}
+
+export async function getDefaultExport(source: string) {
+  if (source.endsWith(".ts")) {
+    const tempFile = source.replace(/\.ts$/, ".temp.js");
+    await build({
+      entryPoints: [source],
+      outfile: tempFile,
+      bundle: true,
+      platform: "node",
+      format: "esm",
+      packages: "external",
+      banner: {
+        js: 'import { createRequire as __createRequire } from "module"; const require = __createRequire(import.meta.url);',
+      },
+    });
+
+    const defaultExport = (await import(pathToFileURL(tempFile).href)).default;
+    fs.unlinkSync(tempFile);
+
+    return defaultExport;
+  } else {
+    return (await import(pathToFileURL(source).href)).default;
+  }
+}
+
+export async function runPreparationScript(fullPath: string | undefined) {
+  if (!fullPath) return undefined;
+
+  const preparationScript = await getDefaultExport(fullPath);
+  if (typeof preparationScript === "function") return await preparationScript();
+  else
+    throw new Error(
+      `Failed to run preparation script: ${fullPath}. Default export is not a function.`,
+    );
+}
+
+export function getAllHbsPartialsInFolder(folder: string) {
+  const partials: HbsPartial[] = [];
+  const files = fs.readdirSync(folder);
+
+  for (const file of files) {
+    if (file.endsWith(".hbs")) {
+      const partialFullName = path.basename(file, ".hbs");
+      if (partialFullName === "template") continue; // skip main template file
+
+      const partialName = partialFullName.split("_")[2];
+      const partialPath = path.join(folder, file);
+
+      partials.push({
+        name: partialName,
+        content: fs.readFileSync(partialPath, "utf8"),
+      });
+    }
+  }
+
+  return partials;
+}
+
+export function getInputDataPath(hbsFolder: string) {
+  const inputPath = path.join(hbsFolder, "input-data.json");
+
+  return fs.existsSync(inputPath) ? inputPath : undefined;
+}
+
+export function getHbsHelpersAndTemplatePaths(hbsFolder: string) {
+  const preparationScriptPath = path.join(hbsFolder, "preparation-script.ts");
+  const helpersPath = path.join(hbsFolder, "hbs-helpers.ts");
+  const templatePath = path.join(hbsFolder, "template.hbs");
+  const partials = getAllHbsPartialsInFolder(hbsFolder);
+
+  if (!fs.existsSync(templatePath)) {
+    throw new Error(`Template file not found: ${templatePath}`);
+  }
+
+  return {
+    preparationScriptPath: fs.existsSync(preparationScriptPath)
+      ? preparationScriptPath
+      : undefined,
+    hbsHelpersPath: fs.existsSync(helpersPath) ? helpersPath : undefined,
+    templatePath: templatePath,
+    hbsPartials: partials,
+  };
+}

package/src/formatting-helpers.ts

@@ -0,0 +1,81 @@
+import { execSync } from "node:child_process";
+import path from "path";
+import prettier from "prettier";
+import fs from "fs";
+
+const jsExtensions = [".ts", ".tsx", ".js", ".jsx"];
+export async function formatJsFileWithPrettier(sourcePath: string) {
+  const filePath = path.resolve(sourcePath);
+  const source = fs.readFileSync(filePath, "utf8");
+
+  const options = await prettier.resolveConfig(filePath);
+
+  const formatted = await prettier.format(source, {
+    ...options,
+    filepath: filePath,
+  });
+
+  if (formatted !== source) {
+    fs.writeFileSync(filePath, formatted, "utf8");
+  }
+}
+
+const csExtensions = [".cs"];
+function formatCsFileWithCSharpier(filePath: string) {
+  const resolved = path.resolve(filePath);
+
+  const toolDir = path.join(process.cwd(), ".csharpier");
+
+  if (!fs.existsSync(toolDir)) {
+    fs.mkdirSync(toolDir);
+
+    execSync("dotnet new tool-manifest", { cwd: toolDir, stdio: "ignore" });
+    execSync("dotnet tool install csharpier", {
+      cwd: toolDir,
+      stdio: "ignore",
+    });
+  }
+
+  execSync(`dotnet tool run csharpier format "${resolved}"`, {
+    cwd: toolDir,
+    stdio: "inherit",
+  });
+}
+
+enum OutputFileType {
+  JavaScript,
+  Csharp,
+}
+
+interface OutputFileFormatter {
+  extensions: string[];
+  formatterFunc: (inputFilePath: string) => Promise<void> | void;
+}
+
+const outputFileTypeMap: Record<OutputFileType, OutputFileFormatter> = {
+  [OutputFileType.JavaScript]: {
+    extensions: jsExtensions,
+    formatterFunc: formatJsFileWithPrettier,
+  },
+  [OutputFileType.Csharp]: {
+    extensions: csExtensions,
+    formatterFunc: formatCsFileWithCSharpier,
+  },
+};
+
+/*
+ * Detects the file type based on extension and formats it with the appropriate formatter.
+ * Currently supports JavaScript/TypeScript files with Prettier and C# files with CSharpier.
+ */
+export async function formatSourceFile(filePath: string) {
+  const ext = filePath.slice(filePath.lastIndexOf("."));
+
+  for (const formatter of Object.values(outputFileTypeMap)) {
+    if (formatter.extensions.includes(ext)) {
+      await formatter.formatterFunc(filePath);
+      return;
+    }
+  }
+
+  throw new Error(`Unsupported output file type: ${ext}`);
+}

package/src/hbs-process-helpers.ts

@@ -0,0 +1,36 @@
+import fs from "fs";
+import Handlebars from "handlebars";
+import { getDefaultExport } from "./file-helpers.js";
+
+export type HbsPartial = {
+  name: string;
+  content: string;
+};
+
+export async function registerHbsHelpersFromFile(fullPath: string) {
+  const hbsHelpers = await getDefaultExport(fullPath);
+
+  for (const [name, value] of Object.entries(hbsHelpers)) {
+    if (typeof value === "function") {
+      Handlebars.registerHelper(name, value as Handlebars.HelperDelegate);
+    }
+  }
+}
+
+export async function registerHbsPartials(partials: HbsPartial[]) {
+  for (const partial of partials) {
+    Handlebars.registerPartial(partial.name, partial.content);
+  }
+}
+
+export async function compileHbsTemplateAndWriteToFile(
+  templatePath: string,
+  inputObject: any,
+  outputFilePath: string,
+) {
+  const template = fs.readFileSync(templatePath, "utf8");
+  const compiled = Handlebars.compile(template);
+
+  const result = compiled(inputObject);
+  fs.writeFileSync(outputFilePath, result);
+}

package/src/process-helpers.ts

@@ -0,0 +1,78 @@
+import {
+  hbsMagicCliUsage,
+  hbsMagicHelp,
+  inputDataNotFound,
+  multipleSourcesDetected,
+  positionalArgumentsNotAllowed,
+} from "./cli-messages.js";
+import { getJson } from "./file-helpers.js";
+
+type ParsedArgs = {
+  [key: string]: string | boolean | string[];
+};
+
+export function extractArguments(process: NodeJS.Process, required: string[]) {
+  const raw = process.argv.slice(2);
+
+  if (raw.length === 1 && raw[0] === "--help") {
+    console.log(hbsMagicHelp);
+    process.exit(1);
+  }
+
+  const args: ParsedArgs = {};
+
+  for (const arg of raw) {
+    if (arg.startsWith("--")) {
+      const [key, value] = arg.slice(2).split("=");
+
+      args[key] = value ?? true;
+    } else {
+      throw new Error(positionalArgumentsNotAllowed);
+    }
+  }
+
+  for (const req of required) {
+    if (!(req in args)) {
+      console.error(`Missing required argument: --${req}`);
+      console.error(hbsMagicCliUsage);
+      process.exit(1);
+    }
+  }
+
+  return args;
+}
+
+export function extractFlag(
+  process: NodeJS.Process,
+  flagName: string,
+): boolean {
+  const arg = process.argv.find((a) => a.startsWith(`--${flagName}`));
+  return !!arg;
+}
+
+export function extractArgument(process: NodeJS.Process, argumentName: string) {
+  const arg = process.argv.find((a) => a.startsWith(`--${argumentName}=`));
+  return arg?.split("=")[1] ?? undefined;
+}
+
+export async function getInputObject(
+  externalJson: string | undefined,
+  preparationScriptResult: any | undefined,
+  inputPath: string | undefined,
+) {
+  if (!externalJson && !preparationScriptResult && !inputPath)
+    throw new Error(inputDataNotFound);
+
+  const sourcesCount =
+    (externalJson ? 1 : 0) +
+    (preparationScriptResult ? 1 : 0) +
+    (inputPath ? 1 : 0);
+
+  if (sourcesCount > 1) console.warn(multipleSourcesDetected);
+
+  if (externalJson) return await getJson(externalJson);
+
+  if (preparationScriptResult) return preparationScriptResult;
+
+  if (inputPath) return await getJson(inputPath);
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "rootDir": ".",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*", "bin/**/*"]
+}

package/tsconfig.node.json

@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "module": "esnext",
+    "moduleResolution": "node"
+  },
+  "include": ["vite.config.mts"]
+}