@highstate/cli 0.16.0 → 0.17.0

package/src/shared/schema-transformer.ts

@@ -50,17 +50,44 @@ async function applyZodMetaTransformations(content: string): Promise<string> {
       // handle zod object patterns
       if (isZodObjectProperty(node, parentStack)) {
         const jsdoc = findLeadingComment(content, node, comments)
-        if (jsdoc) {
-          const description = cleanJsdoc(jsdoc.value)
-          const fieldName =
-            "name" in node.key && typeof node.key.name === "string" ? node.key.name : "unknown"
-          const originalValue = content.substring(node.value.start, node.value.end)
-
-          if (!originalValue.includes(".meta(")) {
-            const newValue = `${originalValue}.meta({ title: __camelCaseToHumanReadable("${fieldName}"), description: \`${description}\` })`
-            result.update(node.value.start, node.value.end, newValue)
-            hasTransformations = true
+        if (!jsdoc) {
+          return
+        }
+
+        const description = cleanJsdoc(jsdoc.value)
+        const fieldName =
+          "name" in node.key && typeof node.key.name === "string" ? node.key.name : "unknown"
+
+        // Getter properties (get foo() { return ... }) need special handling:
+        // we inject `.meta(...)` into the returned schema expression.
+        if (isGetterProperty(node)) {
+          const returnArgument = findFirstReturnArgument(node)
+          if (!returnArgument) {
+            return
           }
+
+          const originalReturnValue = content.substring(returnArgument.start, returnArgument.end)
+          if (originalReturnValue.includes(".meta(")) {
+            return
+          }
+
+          const newReturnValue = `${originalReturnValue}.meta({ title: __camelCaseToHumanReadable("${fieldName}"), description: \`${description}\` })`
+          result.update(returnArgument.start, returnArgument.end, newReturnValue)
+          hasTransformations = true
+          return
+        }
+
+        // Standard properties (foo: z.string())
+        if (!hasValue(node) || !hasSourceRange(node.value)) {
+          return
+        }
+
+        const originalValue = content.substring(node.value.start, node.value.end)
+
+        if (!originalValue.includes(".meta(")) {
+          const newValue = `${originalValue}.meta({ title: __camelCaseToHumanReadable("${fieldName}"), description: \`${description}\` })`
+          result.update(node.value.start, node.value.end, newValue)
+          hasTransformations = true
         }
       }
     },
@@ -101,11 +128,36 @@ async function applyHelperFunctionTransformations(content: string): Promise<stri
 
           if (jsdoc) {
             const description = cleanJsdoc(jsdoc.value)
+            // Getter properties (get foo() { return ... }) need special handling:
+            // inject the helper call into the returned expression.
+            if (isGetterProperty(propertyNode)) {
+              const returnArgument = findFirstReturnArgument(propertyNode)
+              if (!returnArgument) {
+                return
+              }
+
+              const originalReturnValue = content.substring(
+                returnArgument.start,
+                returnArgument.end,
+              )
+              if (originalReturnValue.trimStart().startsWith(`${helperFunction}(`)) {
+                return
+              }
+
+              const newReturnValue = `${helperFunction}(${originalReturnValue}, \`${description}\`)`
+              result.update(returnArgument.start, returnArgument.end, newReturnValue)
+              hasTransformations = true
+              return
+            }
+
+            if (!hasValue(propertyNode) || !hasSourceRange(propertyNode.value)) {
+              return
+            }
+
             const originalValue = content.substring(
               propertyNode.value.start,
               propertyNode.value.end,
             )
-
             const newValue = `${helperFunction}(${originalValue}, \`${description}\`)`
             result.update(propertyNode.value.start, propertyNode.value.end, newValue)
             hasTransformations = true
@@ -242,6 +294,60 @@ function isZodObjectProperty(node: Node, parentStack: Node[]): node is ObjectPro
   )
 }
 
+type GetterObjectProperty = ObjectProperty & {
+  kind: "get"
+  value: Node & { type: "FunctionExpression" }
+}
+
+function isGetterProperty(node: Node): node is GetterObjectProperty {
+  if (node.type !== "Property") {
+    return false
+  }
+
+  if (!hasValue(node)) {
+    return false
+  }
+
+  return "kind" in node && node.kind === "get" && node.value.type === "FunctionExpression"
+}
+
+function findFirstReturnArgument(node: ObjectProperty): Node | null {
+  if (!hasValue(node) || node.value.type !== "FunctionExpression") {
+    return null
+  }
+
+  const body = node.value.body
+  if (!body || body.type !== "BlockStatement") {
+    return null
+  }
+
+  for (const statement of body.body) {
+    if (statement.type !== "ReturnStatement") {
+      continue
+    }
+
+    const returnArgument = "argument" in statement ? statement.argument : null
+    if (returnArgument && hasSourceRange(returnArgument)) {
+      return returnArgument
+    }
+  }
+
+  return null
+}
+
+function hasValue(node: Node): node is Node & { value: Node } {
+  return "value" in node && !!node.value
+}
+
+function hasSourceRange(node: Node): node is Node & { start: number; end: number } {
+  return (
+    "start" in node &&
+    typeof node.start === "number" &&
+    "end" in node &&
+    typeof node.end === "number"
+  )
+}
+
 function findLeadingComment(content: string, node: Node, comments: Comment[]): Comment | null {
   return comments.find(comment => isLeadingComment(content, node, comment)) ?? null
 }

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

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "vitest"
+import { parseFileDependencies } from "./source-hash-calculator"
+
+describe("parseFileDependencies", () => {
+  test("parses relative imports", () => {
+    const filePath = "/repo/src/main.ts"
+    const content = "import { x } from './utils'\n"
+
+    const deps = parseFileDependencies(filePath, content)
+
+    expect(deps).toEqual([
+      {
+        type: "relative",
+        id: "relative:/repo/src/utils",
+        fullPath: "/repo/src/utils",
+      },
+    ])
+  })
+
+  test("parses npm imports", () => {
+    const filePath = "/repo/src/main.ts"
+    const content = "import { mapValues } from 'remeda'\n"
+
+    const deps = parseFileDependencies(filePath, content)
+
+    expect(deps).toEqual([
+      {
+        type: "npm",
+        id: "npm:remeda",
+        package: "remeda",
+      },
+    ])
+  })
+
+  test("ignores node: built-in imports", () => {
+    const filePath = "/repo/src/main.ts"
+    const content = "import { readFile } from 'node:fs/promises'\n"
+
+    const deps = parseFileDependencies(filePath, content)
+
+    expect(deps).toEqual([])
+  })
+
+  test("supports multi-line imports", () => {
+    const filePath = "/repo/src/main.ts"
+    const content = 'import {\n  a,\n  b,\n} from "pkg-types"\n'
+
+    const deps = parseFileDependencies(filePath, content)
+
+    expect(deps).toEqual([
+      {
+        type: "npm",
+        id: "npm:pkg-types",
+        package: "pkg-types",
+      },
+    ])
+  })
+
+  test("does not match identifiers like importBasePath or template strings containing from", () => {
+    const filePath = "/repo/src/main.ts"
+    const content = [
+      "const x = {",
+      "  importBasePath: '/some/path',",
+      "}",
+      // biome-ignore lint/suspicious/noTemplateCurlyInString: false positive
+      'throw new Error(`Cannot use output "foo" from "${input.input.instanceId}"`)\n',
+    ].join("\n")
+
+    const deps = parseFileDependencies(filePath, content)
+
+    expect(deps).toEqual([])
+  })
+})

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

@@ -28,6 +28,44 @@ type FileDependency =
       package: string
     }
 
+export function parseFileDependencies(filePath: string, content: string): FileDependency[] {
+  type DependencyMatch = {
+    relativePath?: string
+    nodeBuiltin?: string
+    npmPackage?: string
+  }
+
+  const dependencyRegex =
+    /^[ \t]*import\b[\s\S]*?\bfrom\s*["']((?<relativePath>\.\.?\/[^"']+)|(?<nodeBuiltin>node:[^"']+)|(?<npmPackage>[^"']+))["']/gm
+
+  const matches = content.matchAll(dependencyRegex)
+  const dependencies: FileDependency[] = []
+
+  for (const match of matches) {
+    const { nodeBuiltin, npmPackage, relativePath } = match.groups as DependencyMatch
+
+    if (relativePath) {
+      const fullPath = resolve(dirname(filePath), relativePath)
+
+      dependencies.push({
+        type: "relative",
+        id: `relative:${fullPath}`,
+        fullPath,
+      })
+    } else if (npmPackage) {
+      dependencies.push({
+        type: "npm",
+        id: `npm:${npmPackage}`,
+        package: npmPackage,
+      })
+    } else if (nodeBuiltin) {
+      // ignore node built-in modules
+    }
+  }
+
+  return dependencies
+}
+
 export class SourceHashCalculator {
   private readonly dependencyHashes = new Map<string, Promise<number>>()
   private readonly fileHashes = new Map<string, Promise<number>>()
@@ -174,7 +212,7 @@ export class SourceHashCalculator {
 
   private async calculateFileHash(fullPath: string): Promise<number> {
     const content = await readFile(fullPath, "utf8")
-    const fileDeps = this.parseDependencies(fullPath, content)
+    const fileDeps = parseFileDependencies(fullPath, content)
 
     const hashes = await Promise.all([
       this.hashString(content),
@@ -284,42 +322,4 @@ export class SourceHashCalculator {
       basePath = resolve(dirname(basePath), "..")
     }
   }
-
-  private parseDependencies(filePath: string, content: string): FileDependency[] {
-    type DependencyMatch = {
-      relativePath?: string
-      nodeBuiltin?: string
-      npmPackage?: string
-    }
-
-    const dependencyRegex =
-      /^[ \t]*import[\s\S]*?\bfrom\s*["']((?<relativePath>\.\.?\/[^"']+)|(?<nodeBuiltin>node:[^"']+)|(?<npmPackage>[^"']+))["']/gm
-
-    const matches = content.matchAll(dependencyRegex)
-    const dependencies: FileDependency[] = []
-
-    for (const match of matches) {
-      const { nodeBuiltin, npmPackage, relativePath } = match.groups as DependencyMatch
-
-      if (relativePath) {
-        const fullPath = resolve(dirname(filePath), relativePath)
-
-        dependencies.push({
-          type: "relative",
-          id: `relative:${fullPath}`,
-          fullPath,
-        })
-      } else if (npmPackage) {
-        dependencies.push({
-          type: "npm",
-          id: `npm:${npmPackage}`,
-          package: npmPackage,
-        })
-      } else if (nodeBuiltin) {
-        // ignore node built-in modules
-      }
-    }
-
-    return dependencies
-  }
 }