@highstate/cli 0.9.14 → 0.9.16

package/src/shared/source-hash-calculator.ts

@@ -3,12 +3,18 @@ import { dirname, relative, resolve } from "node:path"
 import { readFile, writeFile } from "node:fs/promises"
 import { fileURLToPath, pathToFileURL } from "node:url"
 import { readPackageJSON, resolvePackageJSON, type PackageJson } from "pkg-types"
-import { sha256 } from "crypto-hash"
+import { crc32 } from "@aws-crypto/crc32"
 import { resolve as importMetaResolve } from "import-meta-resolve"
-
-export type HighstateManifestJson = {
-  sourceHashes?: Record<string, string>
-}
+import { z } from "zod"
+import { int32ToBytes } from "@highstate/backend/shared"
+import {
+  type HighstateManifest,
+  type HighstateConfig,
+  type SourceHashConfig,
+  highstateConfigSchema,
+  highstateManifestSchema,
+  sourceHashConfigSchema,
+} from "./schemas"
 
 type FileDependency =
   | {
@@ -23,8 +29,8 @@ type FileDependency =
     }
 
 export class SourceHashCalculator {
-  private readonly dependencyHashes = new Map<string, Promise<string>>()
-  private readonly fileHashes = new Map<string, Promise<string>>()
+  private readonly dependencyHashes = new Map<string, Promise<number>>()
+  private readonly fileHashes = new Map<string, Promise<number>>()
 
   constructor(
     private readonly packageJsonPath: string,
@@ -32,21 +38,117 @@ export class SourceHashCalculator {
     private readonly logger: Logger,
   ) {}
 
-  async writeHighstateManifest(distBasePath: string, distPaths: string[]): Promise<void> {
-    const promises: Promise<{ distPath: string; hash: string }>[] = []
+  /**
+   * Calculates CRC32 hash of a string.
+   */
+  private hashString(input: string): number {
+    return crc32(Buffer.from(input))
+  }
 
-    for (const distPath of distPaths) {
-      const fullPath = resolve(distPath)
+  /**
+   * Gets the highstate configuration from package.json with defaults.
+   */
+  private getHighstateConfig(packageJson: PackageJson): HighstateConfig {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const rawConfig = packageJson.highstate
+    if (!rawConfig) {
+      return { type: "source" }
+    }
 
-      promises.push(
-        this.getFileHash(fullPath).then(hash => ({
-          distPath,
-          hash,
-        })),
+    try {
+      return highstateConfigSchema.parse(rawConfig)
+    } catch (error) {
+      this.logger.warn(
+        { error, packageName: packageJson.name },
+        "invalid highstate configuration, using defaults",
       )
+      return { type: "source" }
+    }
+  }
+
+  /**
+   * Gets the effective source hash configuration with defaults for a specific output.
+   */
+  private getSourceHashConfig(
+    highstateConfig: HighstateConfig,
+    exportKey?: string,
+  ): SourceHashConfig {
+    if (highstateConfig.sourceHash) {
+      // Try to parse as a single config first
+      const singleConfigResult = sourceHashConfigSchema.safeParse(highstateConfig.sourceHash)
+      if (singleConfigResult.success) {
+        return singleConfigResult.data
+      }
+
+      // Try to parse as a record of configs
+      const recordConfigResult = z
+        .record(z.string(), sourceHashConfigSchema)
+        .safeParse(highstateConfig.sourceHash)
+      if (recordConfigResult.success && exportKey) {
+        const perOutputConfig = recordConfigResult.data[exportKey]
+        if (perOutputConfig) {
+          return perOutputConfig
+        }
+      }
+    }
+
+    if (highstateConfig.type === "library") {
+      return { mode: "none" }
+    }
+
+    return { mode: "auto" }
+  }
+
+  async writeHighstateManifest(
+    distBasePath: string,
+    distPathToExportKey: Map<string, string>,
+  ): Promise<void> {
+    const highstateConfig = this.getHighstateConfig(this.packageJson)
+
+    const promises: Promise<{ distPath: string; hash: number }>[] = []
+
+    for (const [distPath, exportKey] of distPathToExportKey) {
+      const fullPath = resolve(distPath)
+      const sourceHashConfig = this.getSourceHashConfig(highstateConfig, exportKey)
+
+      switch (sourceHashConfig.mode) {
+        case "manual":
+          promises.push(
+            Promise.resolve({
+              distPath,
+              hash: this.hashString(sourceHashConfig.version),
+            }),
+          )
+          break
+        case "version":
+          promises.push(
+            Promise.resolve({
+              distPath,
+              hash: this.hashString(this.packageJson.version ?? ""),
+            }),
+          )
+          break
+        case "none":
+          promises.push(
+            Promise.resolve({
+              distPath,
+              hash: 0,
+            }),
+          )
+          break
+        case "auto":
+        default:
+          promises.push(
+            this.getFileHash(fullPath).then(hash => ({
+              distPath,
+              hash,
+            })),
+          )
+          break
+      }
     }
 
-    const manifest: HighstateManifestJson = {
+    const manifest: HighstateManifest = {
       sourceHashes: {},
     }
 
@@ -59,7 +161,7 @@ export class SourceHashCalculator {
     await writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf8")
   }
 
-  private async getFileHash(fullPath: string): Promise<string> {
+  private async getFileHash(fullPath: string): Promise<number> {
     const existingHash = this.fileHashes.get(fullPath)
     if (existingHash) {
       return existingHash
@@ -71,19 +173,19 @@ export class SourceHashCalculator {
     return hash
   }
 
-  private async calculateFileHash(fullPath: string): Promise<string> {
+  private async calculateFileHash(fullPath: string): Promise<number> {
     const content = await readFile(fullPath, "utf8")
     const fileDeps = this.parseDependencies(fullPath, content)
 
     const hashes = await Promise.all([
-      sha256(content),
+      this.hashString(content),
       ...fileDeps.map(dep => this.getDependencyHash(dep)),
     ])
 
-    return await sha256(hashes.join(""))
+    return crc32(Buffer.concat(hashes.map(int32ToBytes)))
   }
 
-  getDependencyHash(dependency: FileDependency): Promise<string> {
+  getDependencyHash(dependency: FileDependency): Promise<number> {
     const existingHash = this.dependencyHashes.get(dependency.id)
     if (existingHash) {
       return existingHash
@@ -95,7 +197,7 @@ export class SourceHashCalculator {
     return hash
   }
 
-  private async calculateDependencyHash(dependency: FileDependency): Promise<string> {
+  private async calculateDependencyHash(dependency: FileDependency): Promise<number> {
     switch (dependency.type) {
       case "relative": {
         return await this.getFileHash(dependency.fullPath)
@@ -133,6 +235,7 @@ export class SourceHashCalculator {
           this.logger.warn(`package "%s" is not listed in package.json dependencies`, packageName)
         }
 
+        // try to get source hash from manifest first
         let relativePath = relative(dirname(depPackageJsonPath), resolvedPath)
         relativePath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`
 
@@ -142,10 +245,10 @@ export class SourceHashCalculator {
           "highstate.manifest.json",
         )
 
-        let manifest: HighstateManifestJson | undefined
+        let manifest: HighstateManifest | undefined
         try {
           const manifestContent = await readFile(highstateManifestPath, "utf8")
-          manifest = JSON.parse(manifestContent) as HighstateManifestJson
+          manifest = highstateManifestSchema.parse(JSON.parse(manifestContent))
         } catch (error) {
           this.logger.debug(
             { error },
@@ -164,7 +267,7 @@ export class SourceHashCalculator {
         // use the package version as a fallback hash
         // this case will be applied for most npm packages
         this.logger.debug(`using package version as a fallback hash for "%s"`, packageName)
-        return depPackageJson.version ?? "0.0.0"
+        return this.hashString(depPackageJson.version ?? "0.0.0")
       }
     }
   }