bazis 0.97.3 → 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/di/ServiceProvider.ts

@@ -112,6 +112,23 @@ export class ServiceProvider implements ServiceResolver {
     return this.resolveSingleAsync(token, key, this.lifetime.root, []);
   }
 
+  /**
+   * Creates every singleton registered with an async factory (keyed ones
+   * included), in registration order. Afterwards `resolve` and constructor
+   * injection return the cached instances. The kernel calls it at startup, so a
+   * failing factory stops the start instead of failing every request.
+   */
+  public async initializeAsyncSingletons(): Promise<void> {
+    this.lifetime.assertLive(this.lifetime.root);
+    for (const group of this.registry.groups()) {
+      for (const registration of group) {
+        if (registration.lifetime === "singleton" && isAsyncFactoryProvider(registration.provider)) {
+          await this.resolveRegistrationAsync(registration, registration.key, this.lifetime.root, [], undefined);
+        }
+      }
+    }
+  }
+
   public tryResolve<T>(token: Token<T>, key?: ServiceKey): T | undefined {
     return this.tryResolveForScope(token, key, this.lifetime.root);
   }

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.3" }, 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/kernel/Kernel.ts

@@ -13,6 +13,7 @@ import type { UnhandledErrorPolicy } from "./types";
 import { redactSensitive } from "../../library/redaction";
 import { validateTimeout } from "./internal/validateTimeout";
 import { awaitShutdown } from "./internal/awaitShutdown";
+import { awaitAbortable } from "./internal/awaitAbortable";
 import { reportDiagnosticFailure } from "./internal/reportDiagnosticFailure";
 
 export interface KernelTimings {
@@ -97,6 +98,9 @@ export class Kernel {
       );
     }
     try {
+      // Async singletons first: hosted services and controllers take them
+      // through constructors, which resolve synchronously.
+      await awaitAbortable(this.container.initializeAsyncSingletons(), abortController.signal);
       await this.coordinator.start(abortController.signal, this.options.shutdownTimeoutMs);
       coordinatorStarted = true;
       this.startupMs = performance.now() - this.timings.buildStartedAt;

package/core/scripts/di-generate.ts

@@ -156,6 +156,8 @@ interface CollectedDependency { readonly name: string; readonly target?: ts.Clas
 interface ConstructorDependencies {
   readonly deps: CollectedDependency[];
   readonly unsupportedInheritedParameter?: string;
+  /** An own constructor parameter whose type cannot name a DI dependency (`string`, `number`, an inline type). */
+  readonly unsupportedParameter?: { readonly index: number; readonly name: string; readonly type: string };
 }
 let classDeps = new Map<ts.ClassDeclaration, readonly CollectedDependency[]>();
 let inferredDiClasses = new Set<ts.ClassDeclaration>();
@@ -796,6 +798,10 @@ function collectClassDeps(source: ts.SourceFile): void {
   const visit = (node: ts.Node): void => {
     if (ts.isClassDeclaration(node) && node.name) {
       const result = readConstructorTypeNames(node);
+      if (result.unsupportedParameter !== undefined && needsInferredDiDeps(node)) {
+        const { index, name, type } = result.unsupportedParameter;
+        fatalErrors.push(`BAZIS_DI_DEPENDENCY_UNKNOWN: ${sourceLocation(node)}: constructor parameter ${index + 1} "${name}" of "${node.name.text}" has type "${type}", which cannot be injected: DI resolves dependencies by class, contract or token, and a plain type does not say which value to inject. Declare a token with the same name as a type alias (export type Prefix = string; export const Prefix = createToken<Prefix>("Prefix")) and register a value, or pass the deps explicitly: scoped(${node.name.text}, ${node.name.text}, [TOKEN] as const).`);
+      }
       if (result.unsupportedInheritedParameter !== undefined && needsInferredDiDeps(node)) {
         fatalErrors.push(`BAZIS_DI_CONSTRUCTOR_UNRESOLVED: ${sourceLocation(node)}: cannot infer inherited constructor parameter "${result.unsupportedInheritedParameter}" for "${node.name.text}". The parameter needs a runtime DI token or an explicit value/factory binding.`);
       }
@@ -984,7 +990,7 @@ function readConstructorTypeNames(node: ts.ClassDeclaration): ConstructorDepende
     const paramType = param.type;
     const refName = paramType ? getDependencyTypeName(paramType) : undefined;
     if (!refName || BUILTIN_DEPENDENCY_NAMES.has(refName)) {
-      return { deps: [] };
+      return { deps: [], unsupportedParameter: { index, name: param.name.getText(), type: paramType?.getText() ?? "(no type)" } };
     }
 
     // `Lazy<X>` is a deferred dependency on X: encode it with a marker prefix

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.3",
+  "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
+    }
   }
 }