@tsonic/backend 0.0.1 → 0.0.2

package/src/build-orchestrator.ts

@@ -1,215 +0,0 @@
-/**
- * Main build orchestration - coordinates the entire NativeAOT build process
- */
-
-import { createHash } from "crypto";
-import {
-  mkdirSync,
-  writeFileSync,
-  copyFileSync,
-  rmSync,
-  chmodSync,
-  existsSync,
-  readdirSync,
-} from "fs";
-import { join, dirname } from "path";
-import {
-  BuildOptions,
-  BuildResult,
-  BuildConfig,
-  EntryInfo,
-  NuGetPackage,
-} from "./types.js";
-import { generateCsproj } from "./project-generator.js";
-import { generateProgramCs } from "./program-generator.js";
-import { checkDotnetInstalled, detectRid, publishNativeAot } from "./dotnet.js";
-
-/**
- * Create unique build directory
- */
-const createBuildDir = (entryFile: string): string => {
-  const hash = createHash("md5").update(entryFile).digest("hex").slice(0, 8);
-  const buildDir = join(process.cwd(), ".tsonic", "build", hash);
-  mkdirSync(buildDir, { recursive: true });
-  return buildDir;
-};
-
-/**
- * Copy generated C# files to build directory
- */
-const copyGeneratedFiles = (
-  emittedFiles: Map<string, string>,
-  buildDir: string
-): void => {
-  for (const [tsPath, csContent] of emittedFiles) {
-    // src/models/User.ts → <buildDir>/src/models/User.cs
-    const csPath = tsPath.replace(/\.ts$/, ".cs");
-    const fullPath = join(buildDir, csPath);
-
-    mkdirSync(dirname(fullPath), { recursive: true });
-    writeFileSync(fullPath, csContent, "utf-8");
-  }
-};
-
-/**
- * Find project .csproj file in current directory
- */
-const findProjectCsproj = (): string | null => {
-  const cwd = process.cwd();
-  // Look for *.csproj in current directory
-  const files = readdirSync(cwd);
-  const csprojFile = files.find((f) => f.endsWith(".csproj"));
-  return csprojFile ? join(cwd, csprojFile) : null;
-};
-
-/**
- * Get output binary name for platform
- */
-const getOutputBinaryName = (outputName: string): string => {
-  return process.platform === "win32" ? `${outputName}.exe` : outputName;
-};
-
-/**
- * Copy output binary to final location
- */
-const copyOutputBinary = (
-  buildDir: string,
-  rid: string,
-  outputPath: string,
-  outputName: string
-): void => {
-  const publishDir = join(buildDir, "bin/Release/net8.0", rid, "publish");
-  const binaryName = getOutputBinaryName(outputName);
-  const binaryPath = join(publishDir, binaryName);
-
-  if (!existsSync(binaryPath)) {
-    throw new Error(`Output binary not found at ${binaryPath}`);
-  }
-
-  copyFileSync(binaryPath, outputPath);
-
-  // Make executable on Unix
-  if (process.platform !== "win32") {
-    chmodSync(outputPath, 0o755);
-  }
-};
-
-/**
- * Clean build directory
- */
-const cleanBuild = (buildDir: string, keepTemp: boolean): void => {
-  if (!keepTemp) {
-    rmSync(buildDir, { recursive: true, force: true });
-  }
-};
-
-/**
- * Build NativeAOT executable from C# files
- */
-export const buildNativeAot = (
-  emittedFiles: Map<string, string>,
-  entryInfo: EntryInfo,
-  options: BuildOptions
-): BuildResult => {
-  let buildDir: string | undefined;
-
-  try {
-    // Check dotnet is installed
-    const dotnetCheck = checkDotnetInstalled();
-    if (!dotnetCheck.ok) {
-      return {
-        ok: false,
-        error: dotnetCheck.error,
-      };
-    }
-
-    // Create build directory
-    buildDir = createBuildDir(Array.from(emittedFiles.keys())[0] || "main");
-
-    // Copy generated C# files
-    copyGeneratedFiles(emittedFiles, buildDir);
-
-    // Generate Program.cs if needed
-    if (entryInfo.needsProgram) {
-      const programCs = generateProgramCs(entryInfo);
-      writeFileSync(join(buildDir, "Program.cs"), programCs, "utf-8");
-    }
-
-    // Use existing project .csproj if available, otherwise generate one
-    const projectCsproj = findProjectCsproj();
-    if (projectCsproj) {
-      // Copy existing .csproj to build directory (preserves user edits)
-      const csprojFilename = projectCsproj.split("/").pop() || "project.csproj";
-      copyFileSync(projectCsproj, join(buildDir, csprojFilename));
-    } else {
-      // Generate temporary .csproj for build
-      // Tsonic.Runtime is ALWAYS required (for unions, typeof, structural)
-      // Tsonic.JSRuntime only when mode: "js" (for JS semantics)
-      const packages: NuGetPackage[] = [
-        { name: "Tsonic.Runtime", version: "0.0.1" },
-      ];
-      if (entryInfo.runtime === "js") {
-        packages.push({ name: "Tsonic.JSRuntime", version: "0.0.1" });
-      }
-
-      const buildConfig: BuildConfig = {
-        rootNamespace: options.namespace,
-        outputName: options.outputName || "tsonic",
-        dotnetVersion: options.dotnetVersion || "net10.0",
-        packages,
-        outputConfig: {
-          type: "executable",
-          nativeAot: true,
-          singleFile: true,
-          trimmed: true,
-          stripSymbols: options.stripSymbols ?? true,
-          optimization: options.optimizationPreference || "Speed",
-          invariantGlobalization: true,
-          selfContained: true,
-        },
-      };
-
-      const csprojContent = generateCsproj(buildConfig);
-      writeFileSync(join(buildDir, "tsonic.csproj"), csprojContent, "utf-8");
-    }
-
-    // Detect RID
-    const rid = options.rid || detectRid();
-
-    // Execute dotnet publish
-    const publishResult = publishNativeAot(buildDir, rid);
-    if (!publishResult.ok) {
-      return {
-        ok: false,
-        error: publishResult.error,
-        buildDir,
-      };
-    }
-
-    // Copy output binary
-    const outputPath = options.outputName
-      ? `./${getOutputBinaryName(options.outputName)}`
-      : "./tsonic-app";
-    copyOutputBinary(buildDir, rid, outputPath, options.outputName || "tsonic");
-
-    // Cleanup if requested
-    cleanBuild(buildDir, options.keepTemp ?? false);
-
-    return {
-      ok: true,
-      outputPath,
-      buildDir,
-    };
-  } catch (error) {
-    if (buildDir) {
-      cleanBuild(buildDir, false);
-    }
-
-    return {
-      ok: false,
-      error:
-        error instanceof Error ? error.message : "Unknown build error occurred",
-      buildDir,
-    };
-  }
-};

package/src/dotnet.test.ts

@@ -1,50 +0,0 @@
-/**
- * Tests for dotnet CLI wrapper
- */
-
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import { detectRid } from "./dotnet.js";
-
-describe("Dotnet CLI Wrapper", () => {
-  describe("detectRid", () => {
-    it("should return a valid runtime identifier", () => {
-      const rid = detectRid();
-
-      // Should match one of the known RID patterns
-      const validRids = [
-        "osx-x64",
-        "osx-arm64",
-        "linux-x64",
-        "linux-arm64",
-        "win-x64",
-        "win-arm64",
-      ];
-
-      expect(validRids).to.include(rid);
-    });
-
-    it("should detect current platform RID", () => {
-      const rid = detectRid();
-      const platform = process.platform;
-      const arch = process.arch;
-
-      if (platform === "darwin") {
-        expect(rid).to.match(/^osx-/);
-      } else if (platform === "linux") {
-        expect(rid).to.match(/^linux-/);
-      } else if (platform === "win32") {
-        expect(rid).to.match(/^win-/);
-      }
-
-      if (arch === "x64") {
-        expect(rid).to.include("x64");
-      } else if (arch === "arm64") {
-        expect(rid).to.include("arm64");
-      }
-    });
-  });
-
-  // Note: checkDotnetInstalled and publishNativeAot are integration tests
-  // that require dotnet to be installed, so we skip them in unit tests
-});

package/src/dotnet.ts

@@ -1,101 +0,0 @@
-/**
- * Dotnet CLI wrapper for executing build commands
- */
-
-import { spawnSync } from "child_process";
-import { DotnetResult } from "./types.js";
-
-/**
- * Check if dotnet CLI is available
- */
-export const checkDotnetInstalled = (): DotnetResult => {
-  const result = spawnSync("dotnet", ["--version"], {
-    encoding: "utf-8",
-  });
-
-  if (result.error) {
-    return {
-      ok: false,
-      error: ".NET SDK not found. Install from https://dot.net",
-    };
-  }
-
-  if (result.status !== 0) {
-    return {
-      ok: false,
-      error: "dotnet command failed",
-      stderr: result.stderr,
-    };
-  }
-
-  return {
-    ok: true,
-    stdout: result.stdout.trim(),
-  };
-};
-
-/**
- * Detect runtime identifier for current platform
- */
-export const detectRid = (): string => {
-  const platform = process.platform;
-  const arch = process.arch;
-
-  const ridMap: Record<string, string> = {
-    "darwin-x64": "osx-x64",
-    "darwin-arm64": "osx-arm64",
-    "linux-x64": "linux-x64",
-    "linux-arm64": "linux-arm64",
-    "win32-x64": "win-x64",
-    "win32-arm64": "win-arm64",
-  };
-
-  const key = `${platform}-${arch}`;
-  return ridMap[key] || "linux-x64";
-};
-
-/**
- * Execute dotnet publish with NativeAOT
- */
-export const publishNativeAot = (
-  buildDir: string,
-  rid: string
-): DotnetResult => {
-  const args = [
-    "publish",
-    "tsonic.csproj",
-    "-c",
-    "Release",
-    "-r",
-    rid,
-    "-p:PublishAot=true",
-    "-p:PublishSingleFile=true",
-    "--self-contained",
-  ];
-
-  const result = spawnSync("dotnet", args, {
-    cwd: buildDir,
-    encoding: "utf-8",
-  });
-
-  if (result.error) {
-    return {
-      ok: false,
-      error: `Failed to execute dotnet: ${result.error.message}`,
-    };
-  }
-
-  if (result.status !== 0) {
-    return {
-      ok: false,
-      error: `dotnet publish failed with code ${result.status}`,
-      stdout: result.stdout,
-      stderr: result.stderr,
-    };
-  }
-
-  return {
-    ok: true,
-    stdout: result.stdout,
-  };
-};

package/src/program-generator.test.ts

@@ -1,63 +0,0 @@
-/**
- * Tests for Program.cs generation
- */
-
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import { generateProgramCs } from "./program-generator.js";
-import { EntryInfo } from "./types.js";
-
-describe("Program Generator", () => {
-  describe("generateProgramCs", () => {
-    it("should generate synchronous Main method", () => {
-      const entryInfo: EntryInfo = {
-        namespace: "MyApp",
-        className: "main",
-        methodName: "start",
-        isAsync: false,
-        needsProgram: true,
-      };
-
-      const result = generateProgramCs(entryInfo);
-
-      expect(result).to.include("public static void Main(string[] args)");
-      expect(result).to.include("main.start();");
-      expect(result).to.not.include("await");
-      expect(result).to.not.include("async");
-      expect(result).to.include("using MyApp;");
-    });
-
-    it("should generate async Main method", () => {
-      const entryInfo: EntryInfo = {
-        namespace: "MyApp.Services",
-        className: "main",
-        methodName: "run",
-        isAsync: true,
-        needsProgram: true,
-      };
-
-      const result = generateProgramCs(entryInfo);
-
-      expect(result).to.include("public static async Task Main(string[] args)");
-      expect(result).to.include("await main.run();");
-      expect(result).to.include("using MyApp.Services;");
-      expect(result).to.include("using System.Threading.Tasks;");
-    });
-
-    it("should include required using statements", () => {
-      const entryInfo: EntryInfo = {
-        namespace: "Test",
-        className: "Program",
-        methodName: "Main",
-        isAsync: false,
-        needsProgram: true,
-      };
-
-      const result = generateProgramCs(entryInfo);
-
-      expect(result).to.include("using System;");
-      expect(result).to.include("using Tsonic.Runtime;");
-      expect(result).to.include("using Test;");
-    });
-  });
-});

package/src/program-generator.ts

@@ -1,33 +0,0 @@
-/**
- * Program.cs generation for entry point wrapper
- */
-
-import { EntryInfo } from "./types.js";
-
-/**
- * Generate Program.cs content with Main method
- */
-export const generateProgramCs = (entryInfo: EntryInfo): string => {
-  const returnType = entryInfo.isAsync ? "async Task" : "void";
-  const awaitKeyword = entryInfo.isAsync ? "await " : "";
-
-  const usings = ["using System;", "using System.Threading.Tasks;"];
-
-  // Only include Tsonic.Runtime for js runtime mode
-  if (entryInfo.runtime !== "dotnet") {
-    usings.push("using Tsonic.Runtime;");
-  }
-
-  usings.push(`using ${entryInfo.namespace};`);
-
-  return `${usings.join("\n")}
-
-public static class Program
-{
-    public static ${returnType} Main(string[] args)
-    {
-        ${awaitKeyword}${entryInfo.className}.${entryInfo.methodName}();
-    }
-}
-`;
-};

package/src/project-generator.test.ts

@@ -1,130 +0,0 @@
-/**
- * Tests for .csproj generation
- */
-
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import { generateCsproj } from "./project-generator.js";
-import { BuildConfig } from "./types.js";
-
-describe("Project Generator", () => {
-  describe("generateCsproj", () => {
-    it("should generate basic executable .csproj without packages", () => {
-      const config: BuildConfig = {
-        rootNamespace: "TestApp",
-        outputName: "test",
-        dotnetVersion: "net10.0",
-        packages: [],
-        outputConfig: {
-          type: "executable",
-          nativeAot: true,
-          singleFile: true,
-          trimmed: true,
-          stripSymbols: true,
-          optimization: "Speed",
-          invariantGlobalization: true,
-          selfContained: true,
-        },
-      };
-
-      const result = generateCsproj(config);
-
-      expect(result).to.include('<Project Sdk="Microsoft.NET.Sdk">');
-      expect(result).to.include("<TargetFramework>net10.0</TargetFramework>");
-      expect(result).to.include("<RootNamespace>TestApp</RootNamespace>");
-      expect(result).to.include("<AssemblyName>test</AssemblyName>");
-      expect(result).to.include("<PublishAot>true</PublishAot>");
-      expect(result).to.include(
-        "<OptimizationPreference>Speed</OptimizationPreference>"
-      );
-    });
-
-    it("should include package references when provided", () => {
-      const config: BuildConfig = {
-        rootNamespace: "TestApp",
-        outputName: "test",
-        dotnetVersion: "net10.0",
-        packages: [
-          { name: "System.Text.Json", version: "8.0.0" },
-          { name: "Newtonsoft.Json", version: "13.0.3" },
-        ],
-        outputConfig: {
-          type: "executable",
-          nativeAot: true,
-          singleFile: true,
-          trimmed: true,
-          stripSymbols: true,
-          optimization: "Size",
-          invariantGlobalization: true,
-          selfContained: true,
-        },
-      };
-
-      const result = generateCsproj(config);
-
-      expect(result).to.include(
-        '<PackageReference Include="System.Text.Json" Version="8.0.0"'
-      );
-      expect(result).to.include(
-        '<PackageReference Include="Newtonsoft.Json" Version="13.0.3"'
-      );
-      expect(result).to.include(
-        "<OptimizationPreference>Size</OptimizationPreference>"
-      );
-    });
-
-    it("should set invariant globalization correctly", () => {
-      const config: BuildConfig = {
-        rootNamespace: "TestApp",
-        outputName: "test",
-        dotnetVersion: "net10.0",
-        packages: [],
-        outputConfig: {
-          type: "executable",
-          nativeAot: true,
-          singleFile: true,
-          trimmed: true,
-          stripSymbols: false,
-          optimization: "Speed",
-          invariantGlobalization: false,
-          selfContained: true,
-        },
-      };
-
-      const result = generateCsproj(config);
-
-      expect(result).to.include(
-        "<InvariantGlobalization>false</InvariantGlobalization>"
-      );
-      expect(result).to.include("<StripSymbols>false</StripSymbols>");
-    });
-
-    it("should generate library .csproj", () => {
-      const config: BuildConfig = {
-        rootNamespace: "TestLib",
-        outputName: "testlib",
-        dotnetVersion: "net10.0",
-        packages: [],
-        outputConfig: {
-          type: "library",
-          targetFrameworks: ["net8.0", "net9.0"],
-          generateDocumentation: true,
-          includeSymbols: true,
-          packable: false,
-        },
-      };
-
-      const result = generateCsproj(config);
-
-      expect(result).to.include("<OutputType>Library</OutputType>");
-      expect(result).to.include(
-        "<TargetFrameworks>net8.0;net9.0</TargetFrameworks>"
-      );
-      expect(result).to.include(
-        "<GenerateDocumentationFile>true</GenerateDocumentationFile>"
-      );
-      expect(result).to.include("<DebugType>embedded</DebugType>");
-      expect(result).to.include("<IsPackable>false</IsPackable>");
-    });
-  });
-});