bazis 0.97.4 → 0.97.5

package/README.md

@@ -15,9 +15,10 @@ executable.
   (`ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`), and the runtime uses Bun
   APIs throughout: `Bun.serve`, `Bun.SQL`, the built-in Redis client,
   `bun:test`, `bun build --compile`.
-- TypeScript 5.9 or newer as a peer dependency: the code generator reads
-  your sources through the TypeScript compiler API. Nothing is compiled to
-  JavaScript.
+- TypeScript 5.9, 6 or 7 as a peer dependency: the code generator reads
+  your sources through the TypeScript compiler API. With TypeScript 7, which
+  has no such API, also install `@typescript/typescript6`. Nothing is
+  compiled to JavaScript.
 - PostgreSQL for the ORM.
 - Qualified platforms: macOS arm64, Linux x64 and arm64.
 
@@ -40,9 +41,20 @@ bunx bazis dev            # GET http://127.0.0.1:3000/health
 
 ```sh
 bun add bazis             # or a fixed version: bun add bazis@0.96.2
-bun add -d typescript@^6 @types/bun   # TypeScript 7 is not supported yet
+bun add -d typescript@^6 @types/bun
 ```
 
+TypeScript 7 also works. It ships no compiler API, which the code generator
+needs, so add Microsoft's TypeScript 6 API package next to it:
+
+```sh
+bun add -d typescript@^7 @typescript/typescript6 @types/bun
+```
+
+The project keeps type-checking with TypeScript 7; only codegen reads the
+sources through the TypeScript 6 API. Without `@typescript/typescript6`
+codegen stops with `BAZIS_TYPESCRIPT_API_MISSING` and this install command.
+
 Then take `tsconfig.json`, `bazis.config.json` and `src/index.ts` from a
 project made by `bazis new` as the starting point, and run `bunx bazis codegen`.
 

package/cli/codegen.ts

@@ -11,7 +11,10 @@ export async function runCodegen(cwd: string, target?: string): Promise<number>
     const config = await configFile.json();
     if (target !== "all" && !Object.hasOwn(config.targets ?? {}, target)) throw new Error(`Unknown codegen target: ${target}`);
   }
-  const args = [await resolveBun(cwd), resolveGenerator(cwd), ...(target === undefined ? [] : ["--target", target])];
+  const generator = resolveGenerator(cwd);
+  // TypeScript 7 has no compiler API: the preload switches it to @typescript/typescript6.
+  const preload = path.join(path.dirname(generator), "typescriptApiPreload.ts");
+  const args = [await resolveBun(cwd), ...(existsSync(preload) ? ["--preload", preload] : []), generator, ...(target === undefined ? [] : ["--target", target])];
   return await Bun.spawn(args, { cwd, stdout: "inherit", stderr: "inherit" }).exited;
 }
 

package/cli/main.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { generateModule, generateModulePack } from "./generateModule";
+import { useTypeScriptCompilerApi } from "../core/scripts/typescriptApi";
 import { parseCliArgs } from "./parseCli";
 import { runCodegen } from "./codegen";
 import { generateProject } from "./generateProject";
@@ -100,6 +100,10 @@ export async function runCli(argv: readonly string[], runtime: CliRuntime = defa
       name: args.name, modulesRoot: args.modulesRoot, appModulePath: args.appModule,
       register: args.register, force: args.force, dryRun: args.dryRun,
     };
+    // Module registration parses the host module with the TypeScript API: load it
+    // only after switching TypeScript 7 to @typescript/typescript6.
+    useTypeScriptCompilerApi(process.cwd());
+    const { generateModule, generateModulePack } = await import("./generateModule");
     const result = args.generator === "pack"
       ? await generateModulePack({ ...options, parts: args.parts })
       : await generateModule({ ...options, profile: args.profile });

package/core/infra/connectors/codex/CodexAppServerClient.ts

@@ -232,7 +232,7 @@ export class CodexAppServerClient implements CodexClient {
         if (method === "account/updated") this.modelCache = undefined;
       }, () => { this.clearLogin(); this.modelCache = undefined; });
       const initialized = await client.request("initialize", {
-        clientInfo: { name: "bazis", title: "Bazis", version: "0.97.4" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.97.5" }, capabilities: { experimentalApi: true },
       }, 15_000, signal);
       if (resolve(text(initialized.codexHome, 4096)) !== this.paths.home) throw new CodexError("PROTOCOL_ERROR");
       client.notify("initialized");

package/core/scripts/typescriptApi.ts

@@ -0,0 +1,61 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { plugin } from "bun";
+
+/**
+ * bazis codegen uses the TypeScript compiler API (`createProgram`, the type
+ * checker). TypeScript 7 no longer ships it: `import ts from "typescript"`
+ * gives only the version. Microsoft publishes the TypeScript 6 API as
+ * `@typescript/typescript6`. When the `typescript` package seen from `fromDir`
+ * is 7 or newer, this makes `import ts from "typescript"` in the current
+ * process load that package instead. The project keeps TypeScript 7 as its
+ * compiler (`tsc`).
+ *
+ * Must run before anything imports "typescript": as a `--preload` of the
+ * codegen process, or in the CLI before its first dynamic import that needs it.
+ * Does nothing when `typescript` cannot be resolved (for example inside the
+ * compiled CLI binary, which bundles its own compiler API).
+ */
+export function useTypeScriptCompilerApi(fromDir: string): void {
+  let entry: string;
+  try {
+    entry = Bun.resolveSync("typescript", fromDir);
+  } catch {
+    return;
+  }
+  const major = Number.parseInt(packageVersion(entry, "typescript")?.split(".")[0] ?? "", 10);
+  if (!Number.isFinite(major) || major < 7) return;
+
+  let api: string;
+  try {
+    api = Bun.resolveSync("@typescript/typescript6", fromDir);
+  } catch {
+    throw new Error(
+      `BAZIS_TYPESCRIPT_API_MISSING: TypeScript ${major} has no compiler API, and bazis codegen needs one. ` +
+        "Install the TypeScript 6 API next to it: bun add -d @typescript/typescript6",
+    );
+  }
+  const exact = new RegExp(`^${entry.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`);
+  plugin({
+    name: "bazis-typescript6-api",
+    setup(build) {
+      build.onLoad({ filter: exact }, () => ({
+        contents: `import ts from ${JSON.stringify(api)};\nexport default ts;\n`,
+        loader: "js",
+      }));
+    },
+  });
+}
+
+/** Version from the package.json of the package that contains `file`. */
+function packageVersion(file: string, name: string): string | undefined {
+  for (let dir = path.dirname(file); dir !== path.dirname(dir); dir = path.dirname(dir)) {
+    try {
+      const manifest = JSON.parse(readFileSync(path.join(dir, "package.json"), "utf8")) as { name?: string; version?: string };
+      if (manifest.name === name) return manifest.version;
+    } catch {
+      // No package.json at this level: keep walking up.
+    }
+  }
+  return undefined;
+}

package/core/scripts/typescriptApiPreload.ts

@@ -0,0 +1,9 @@
+// Preloaded into the codegen process (`bun --preload`): see useTypeScriptCompilerApi.
+import { useTypeScriptCompilerApi } from "./typescriptApi";
+
+try {
+  useTypeScriptCompilerApi(import.meta.dir);
+} catch (error) {
+  console.error(`[bazis] ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+}

package/library/orm/Providers/OwnedStoreCatalog.reader.ts

@@ -653,8 +653,11 @@ export class OwnedStoreCatalogReader {
     readonly OwnedCatalogArrayTypeV1[]
   ]> {
     const relationOids = relations.filter(relation => relation.rowTypeOid !== null).map(relation => relation.oid);
-    if (!relationOids.length)
-      return Object.freeze([Object.freeze([]), Object.freeze([])]);
+    if (!relationOids.length) {
+      // An explicit tuple: TypeScript 7 infers Object.freeze([a, b]) as an array.
+      const empty: readonly [readonly OwnedCatalogRowTypeV1[], readonly OwnedCatalogArrayTypeV1[]] = [Object.freeze([]), Object.freeze([])];
+      return Object.freeze(empty);
+    }
     const rowTypes: OwnedCatalogRowTypeV1[] = [], arrayTypes: OwnedCatalogArrayTypeV1[] = [];
     for (let offset = 0; offset < relationOids.length; offset += 1024) {
       const batch = relationOids.slice(offset, offset + 1024), parameter = this.encodePgOidArrayParameter(batch), issuedLimit = Math.min(batch.length + 1, budget.remaining + 1);
@@ -693,7 +696,8 @@ export class OwnedStoreCatalogReader {
         this.source.drift();
       }
     }
-    return Object.freeze([Object.freeze(rowTypes), Object.freeze(arrayTypes)]);
+    const types: readonly [readonly OwnedCatalogRowTypeV1[], readonly OwnedCatalogArrayTypeV1[]] = [Object.freeze(rowTypes), Object.freeze(arrayTypes)];
+    return Object.freeze(types);
   }
   private async readColumns(relations: readonly OwnedCatalogRelationV1[], operation: "registry-read" | "catalog-read", budget: {
     remaining: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.97.4",
+  "version": "0.97.5",
   "description": "Modular backend framework for Bun in TypeScript: DI wired by codegen, HTTP, a PostgreSQL ORM, JWT, WebSocket, agents and a CLI.",
   "license": "MIT",
   "author": "Alexander Alenin",
@@ -71,10 +71,16 @@
     "bun": ">=1.4.0"
   },
   "peerDependencies": {
-    "typescript": "^5.9.3 || ^6.0.0"
+    "typescript": "^5.9.3 || ^6.0.0 || ^7.0.0",
+    "@typescript/typescript6": "^6.0.0"
   },
   "publishConfig": {
     "access": "public",
     "provenance": true
+  },
+  "peerDependenciesMeta": {
+    "@typescript/typescript6": {
+      "optional": true
+    }
   }
 }