@highstate/cli 0.9.16 → 0.9.19

package/src/shared/workspace.ts

@@ -0,0 +1,240 @@
+import { readdir, readFile, writeFile, mkdir } from "node:fs/promises"
+import { join, relative, resolve } from "node:path"
+import { existsSync } from "node:fs"
+import { z } from "zod"
+import { highstateConfigSchema } from "./schemas"
+
+/**
+ * Represents a Highstate package in the workspace
+ */
+export interface HighstatePackage {
+  /** Absolute path to the package directory */
+  path: string
+  /** Relative path from workspace root */
+  relativePath: string
+  /** Package name from package.json */
+  name: string
+  /** Package type from highstate config */
+  type?: "source" | "library" | "worker"
+}
+
+/**
+ * Schema for package.json files
+ */
+const packageJsonSchema = z.object({
+  name: z.string(),
+  highstate: highstateConfigSchema.optional(),
+})
+
+/**
+ * Generates tsconfig content with correct relative path based on package depth
+ */
+function generateTsconfigContent(workspaceRoot: string, packagePath: string) {
+  const relativePath = relative(workspaceRoot, packagePath)
+  const depth = relativePath.split("/").length
+  const relativeNodeModules = `${"../".repeat(depth)}node_modules/@highstate/cli/assets/tsconfig.base.json`
+
+  return {
+    extends: relativeNodeModules,
+    include: ["./src/**/*.ts", "./package.json", "./assets/**/*.json"],
+  }
+}
+
+/**
+ * Finds the workspace root by looking for package.json with workspaces
+ */
+export async function findWorkspaceRoot(startPath: string = process.cwd()): Promise<string> {
+  let currentPath = resolve(startPath)
+
+  while (currentPath !== "/") {
+    const packageJsonPath = join(currentPath, "package.json")
+
+    if (existsSync(packageJsonPath)) {
+      try {
+        const content = await readFile(packageJsonPath, "utf-8")
+        const packageJson = JSON.parse(content) as { workspaces?: unknown }
+
+        if (packageJson.workspaces) {
+          return currentPath
+        }
+      } catch {
+        // ignore invalid package.json files
+      }
+    }
+
+    const parentPath = resolve(currentPath, "..")
+    if (parentPath === currentPath) break
+    currentPath = parentPath
+  }
+
+  throw new Error("Could not find workspace root (no package.json with workspaces found)")
+}
+
+/**
+ * Recursively scans for packages in the workspace
+ */
+export async function scanWorkspacePackages(workspaceRoot: string): Promise<HighstatePackage[]> {
+  const packages: HighstatePackage[] = []
+  const packagesDir = join(workspaceRoot, "packages")
+
+  if (!existsSync(packagesDir)) {
+    return packages
+  }
+
+  async function scanDirectory(dirPath: string, depth = 0): Promise<void> {
+    // skip node_modules and hidden directories at any depth
+    const dirName = relative(packagesDir, dirPath).split("/").pop()
+    if (dirName?.startsWith(".") || dirName === "node_modules") {
+      return
+    }
+
+    const entries = await readdir(dirPath, { withFileTypes: true })
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue
+
+      const entryPath = join(dirPath, entry.name)
+
+      // skip node_modules and hidden directories
+      if (entry.name.startsWith(".") || entry.name === "node_modules") {
+        continue
+      }
+
+      const packageJsonPath = join(entryPath, "package.json")
+
+      // check if this directory has a package.json
+      if (existsSync(packageJsonPath)) {
+        try {
+          const content = await readFile(packageJsonPath, "utf-8")
+          const packageJson = packageJsonSchema.parse(JSON.parse(content))
+
+          const relativePath = relative(workspaceRoot, entryPath)
+          const type = packageJson.highstate?.type ?? "source"
+
+          packages.push({
+            path: entryPath,
+            relativePath,
+            name: packageJson.name,
+            type,
+          })
+        } catch {
+          // ignore directories with invalid package.json files
+        }
+      }
+
+      // continue scanning subdirectories, but with limited depth to avoid deep node_modules
+      if (depth < 3) {
+        await scanDirectory(entryPath, depth + 1)
+      }
+    }
+  }
+
+  await scanDirectory(packagesDir)
+  return packages.sort((a, b) => a.relativePath.localeCompare(b.relativePath))
+}
+
+/**
+ * Updates the root tsconfig.json with package references
+ */
+export async function updateTsconfigReferences(
+  workspaceRoot: string,
+  packages: HighstatePackage[],
+  ensureTsconfigs = false,
+): Promise<void> {
+  const tsconfigPath = join(workspaceRoot, "tsconfig.json")
+
+  // ensure all packages have valid tsconfig.json files
+  if (ensureTsconfigs) {
+    await ensurePackageTsconfigs(
+      workspaceRoot,
+
+      // only udate for Highstate-managed packages
+      packages.filter(pkg => pkg.type !== undefined),
+    )
+  }
+
+  // generate references array
+  const references = packages.map(pkg => ({
+    path: `./${pkg.relativePath}/tsconfig.json`,
+  }))
+
+  const tsconfigContent = {
+    files: [],
+    references,
+  }
+
+  // write the file with proper formatting
+  await writeFile(tsconfigPath, `${JSON.stringify(tsconfigContent, null, 2)}\n`, "utf-8")
+}
+
+/**
+ * Ensures all packages have valid tsconfig.json files
+ */
+async function ensurePackageTsconfigs(
+  workspaceRoot: string,
+  packages: HighstatePackage[],
+): Promise<void> {
+  for (const pkg of packages) {
+    const tsconfigPath = join(pkg.path, "tsconfig.json")
+    const tsconfigContent = generateTsconfigContent(workspaceRoot, pkg.path)
+
+    await writeFile(tsconfigPath, `${JSON.stringify(tsconfigContent, null, 2)}\n`, "utf-8")
+  }
+}
+
+/**
+ * Creates a new package of the specified type
+ */
+export async function createPackage(
+  workspaceRoot: string,
+  name: string,
+  type: "source" | "library" | "worker",
+): Promise<HighstatePackage> {
+  const packagePath = join(workspaceRoot, "packages", name)
+  const srcPath = join(packagePath, "src")
+
+  // create directories
+  await mkdir(packagePath, { recursive: true })
+  await mkdir(srcPath, { recursive: true })
+
+  // create package.json
+  const packageJson = {
+    name: `@highstate/${name}`,
+    version: "0.0.1",
+    type: "module",
+    highstate: {
+      type,
+    },
+  }
+
+  await writeFile(
+    join(packagePath, "package.json"),
+    `${JSON.stringify(packageJson, null, 2)}\n`,
+    "utf-8",
+  )
+
+  // create tsconfig.json
+  const tsconfigContent = generateTsconfigContent(workspaceRoot, packagePath)
+  await writeFile(
+    join(packagePath, "tsconfig.json"),
+    `${JSON.stringify(tsconfigContent, null, 2)}\n`,
+    "utf-8",
+  )
+
+  // create CHANGELOG.md
+  await writeFile(
+    join(packagePath, "CHANGELOG.md"),
+    `# Changelog\n\nAll notable changes to this project will be documented in this file.\n`,
+    "utf-8",
+  )
+
+  // create basic index.ts
+  await writeFile(join(srcPath, "index.ts"), `// ${name} package\n`, "utf-8")
+
+  return {
+    path: packagePath,
+    relativePath: `packages/${name}`,
+    name: `@highstate/${name}`,
+    type,
+  }
+}

package/dist/library-loader-CGEPTS4L.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/shared/library-loader.ts"],"sourcesContent":["import type { Logger } from \"pino\"\nimport {\n  type Component,\n  type ComponentModel,\n  type Entity,\n  isComponent,\n  isEntity,\n  isUnitModel,\n  originalCreate,\n} from \"@highstate/contract\"\nimport { serializeFunction } from \"@pulumi/pulumi/runtime/index.js\"\nimport { Crc32, crc32 } from \"@aws-crypto/crc32\"\nimport { encode } from \"@msgpack/msgpack\"\nimport { int32ToBytes } from \"@highstate/backend/shared\"\n\nexport type Library = Readonly<{\n  components: Readonly<Record<string, ComponentModel>>\n  entities: Readonly<Record<string, Entity>>\n}>\n\nexport async function loadLibrary(logger: Logger, modulePaths: string[]): Promise<Library> {\n  const modules: Record<string, unknown> = {}\n  for (const modulePath of modulePaths) {\n    try {\n      logger.debug({ modulePath }, \"loading module\")\n      modules[modulePath] = await import(modulePath)\n\n      logger.debug({ modulePath }, \"module loaded\")\n    } catch (err) {\n      logger.error({ modulePath, err }, \"module load failed\")\n    }\n  }\n\n  const components: Record<string, ComponentModel> = {}\n  const entities: Record<string, Entity> = {}\n\n  await _loadLibrary(modules, components, entities)\n\n  logger.info(\n    {\n      componentCount: Object.keys(components).length,\n      entityCount: Object.keys(entities).length,\n    },\n    \"library loaded\",\n  )\n\n  logger.trace({ components, entities }, \"library content\")\n\n  return { components, entities }\n}\n\nasync function _loadLibrary(\n  value: unknown,\n  components: Record<string, ComponentModel>,\n  entities: Record<string, Entity>,\n): Promise<void> {\n  if (isComponent(value)) {\n    const entityHashes: number[] = []\n    for (const entity of value.entities.values()) {\n      entity.definitionHash ??= calculateEntityDefinitionHash(entity)\n      entityHashes.push(entity.definitionHash)\n    }\n\n    components[value.model.type] = value.model\n    value.model.definitionHash = await calculateComponentDefinitionHash(value, entityHashes)\n\n    return\n  }\n\n  if (isEntity(value)) {\n    entities[value.type] = value\n    entities[value.type].definitionHash ??= calculateEntityDefinitionHash(value)\n\n    // @ts-expect-error remove the schema since it's not needed in the designer\n    delete value.schema\n    return\n  }\n\n  if (typeof value !== \"object\" || value === null) {\n    return\n  }\n\n  for (const key in value) {\n    await _loadLibrary((value as Record<string, unknown>)[key], components, entities)\n  }\n}\n\nasync function calculateComponentDefinitionHash(\n  component: Component,\n  entityHashes: number[],\n): Promise<number> {\n  const result = new Crc32()\n\n  // 1. include the full component model\n  result.update(encode(component.model))\n\n  if (!isUnitModel(component.model)) {\n    // 2. for composite components, include the content of the serialized create function\n    const serializedCreate = await serializeFunction(component[originalCreate])\n    result.update(Buffer.from(serializedCreate.text))\n  }\n\n  // 3. include the hashes of all entities\n  for (const entityHash of entityHashes) {\n    result.update(int32ToBytes(entityHash))\n  }\n\n  return result.digest()\n}\n\nfunction calculateEntityDefinitionHash(entity: Entity): number {\n  return crc32(encode(entity))\n}\n"],"mappings":";AACA;AAAA,EAIE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,yBAAyB;AAClC,SAAS,OAAO,aAAa;AAC7B,SAAS,cAAc;AACvB,SAAS,oBAAoB;AAO7B,eAAsB,YAAY,QAAgB,aAAyC;AACzF,QAAM,UAAmC,CAAC;AAC1C,aAAW,cAAc,aAAa;AACpC,QAAI;AACF,aAAO,MAAM,EAAE,WAAW,GAAG,gBAAgB;AAC7C,cAAQ,UAAU,IAAI,MAAM,OAAO;AAEnC,aAAO,MAAM,EAAE,WAAW,GAAG,eAAe;AAAA,IAC9C,SAAS,KAAK;AACZ,aAAO,MAAM,EAAE,YAAY,IAAI,GAAG,oBAAoB;AAAA,IACxD;AAAA,EACF;AAEA,QAAM,aAA6C,CAAC;AACpD,QAAM,WAAmC,CAAC;AAE1C,QAAM,aAAa,SAAS,YAAY,QAAQ;AAEhD,SAAO;AAAA,IACL;AAAA,MACE,gBAAgB,OAAO,KAAK,UAAU,EAAE;AAAA,MACxC,aAAa,OAAO,KAAK,QAAQ,EAAE;AAAA,IACrC;AAAA,IACA;AAAA,EACF;AAEA,SAAO,MAAM,EAAE,YAAY,SAAS,GAAG,iBAAiB;AAExD,SAAO,EAAE,YAAY,SAAS;AAChC;AAEA,eAAe,aACb,OACA,YACA,UACe;AACf,MAAI,YAAY,KAAK,GAAG;AACtB,UAAM,eAAyB,CAAC;AAChC,eAAW,UAAU,MAAM,SAAS,OAAO,GAAG;AAC5C,aAAO,mBAAmB,8BAA8B,MAAM;AAC9D,mBAAa,KAAK,OAAO,cAAc;AAAA,IACzC;AAEA,eAAW,MAAM,MAAM,IAAI,IAAI,MAAM;AACrC,UAAM,MAAM,iBAAiB,MAAM,iCAAiC,OAAO,YAAY;AAEvF;AAAA,EACF;AAEA,MAAI,SAAS,KAAK,GAAG;AACnB,aAAS,MAAM,IAAI,IAAI;AACvB,aAAS,MAAM,IAAI,EAAE,mBAAmB,8BAA8B,KAAK;AAG3E,WAAO,MAAM;AACb;AAAA,EACF;AAEA,MAAI,OAAO,UAAU,YAAY,UAAU,MAAM;AAC/C;AAAA,EACF;AAEA,aAAW,OAAO,OAAO;AACvB,UAAM,aAAc,MAAkC,GAAG,GAAG,YAAY,QAAQ;AAAA,EAClF;AACF;AAEA,eAAe,iCACb,WACA,cACiB;AACjB,QAAM,SAAS,IAAI,MAAM;AAGzB,SAAO,OAAO,OAAO,UAAU,KAAK,CAAC;AAErC,MAAI,CAAC,YAAY,UAAU,KAAK,GAAG;AAEjC,UAAM,mBAAmB,MAAM,kBAAkB,UAAU,cAAc,CAAC;AAC1E,WAAO,OAAO,OAAO,KAAK,iBAAiB,IAAI,CAAC;AAAA,EAClD;AAGA,aAAW,cAAc,cAAc;AACrC,WAAO,OAAO,aAAa,UAAU,CAAC;AAAA,EACxC;AAEA,SAAO,OAAO,OAAO;AACvB;AAEA,SAAS,8BAA8B,QAAwB;AAC7D,SAAO,MAAM,OAAO,MAAM,CAAC;AAC7B;","names":[]}