bazis 0.98.13 → 0.98.15

package/core/di/internal/GraphValidator.ts

@@ -110,7 +110,9 @@ export class GraphValidator {
 
         if (this.context.validateScopes && rootLifetime === "singleton" && depRegistration.lifetime === "scoped") {
           issues.add(
-            `Singleton "${tokenToDebugName(registration.token)}" depends on scoped "${tokenToDebugName(descriptor.token)}"`,
+            `Singleton "${tokenToDebugName(registration.token)}" depends on scoped "${tokenToDebugName(descriptor.token)}". `
+              + `A scoped service lives for one request or scope: make "${tokenToDebugName(registration.token)}" scoped too, `
+              + `or inject ServiceProvider and resolve "${tokenToDebugName(descriptor.token)}" in a scope you create (provider.createScope()).`,
           );
         }
 

package/core/di/module/encapsulation.ts

@@ -173,6 +173,14 @@ export function validateModuleEncapsulation(
   // Why a provided token is not visible: the owner does not export it, or the
   // consumer module does not import the owner. Both used to read "not exported".
   const explainHidden = (token: Token<unknown>, consumer: ModuleGraphRecord): string => {
+    // A module the consumer imports already sees the token but does not pass it
+    // on. That export is the fix, whatever inner module (an `ormBazis` feature
+    // module, say) registered the token.
+    const blocking = consumer.imports.find((imported) => !imported.providedTokens.has(token)
+      && !exportedTokens(imported).has(token) && visibleTokens(imported).has(token));
+    if (blocking !== undefined) {
+      return `which its import "${blocking.name}" receives from its own imports but does not export. Add it to the exports of "${blocking.name}".`;
+    }
     const owner = records.find((record) => record !== consumer && record.providedTokens.has(token));
     if (owner === undefined) return "which is provided by another module but not exported.";
     return exportedTokens(owner).has(token)

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.98.13" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.98.15" }, capabilities: { experimentalApi: true },
       }, 15_000, signal);
       if (resolve(text(initialized.codexHome, 4096)) !== this.paths.home) throw new CodexError("PROTOCOL_ERROR");
       client.notify("initialized");

package/library/orm/Metadata/ModelBuilder.ts

@@ -38,8 +38,10 @@ export class ModelBuilder {
     const indexes: IndexModel[] = [];
     const foreignKeys: ForeignKeyModel[] = [];
     let explicitKey: PropertyModel | undefined;
+    const sample = ModelBuilder.sampleOf(ctor);
 
     for (const rawProp of raw.properties.values()) {
+      ModelBuilder.assertTypeMatchesInitializer(ctor.name, rawProp, sample);
       const property = ModelBuilder.buildProperty(ctor.name, rawProp);
       properties.push(property);
       if (property.isKey) {
@@ -184,6 +186,43 @@ export class ModelBuilder {
     return model;
   }
 
+  /** A fresh instance shows the initial values; an entity whose constructor throws skips the check. */
+  private static sampleOf(ctor: new () => object): Record<string, unknown> | undefined {
+    try {
+      return new ctor() as Record<string, unknown>;
+    } catch {
+      return undefined;
+    }
+  }
+
+  /**
+   * A column without an explicit type maps to `text` (a key to an integer
+   * identity). When the initial value says otherwise (`pages = 0`,
+   * `code = ""` on a key), the mapping would silently change the value's type
+   * or drop it, so the model refuses to build and names the type to set.
+   */
+  private static assertTypeMatchesInitializer(entityName: string, raw: RawProperty, sample: Record<string, unknown> | undefined): void {
+    if (sample === undefined || raw.type !== undefined || raw.convention !== undefined || raw.converter !== undefined) return;
+    const initial = sample[raw.propertyName];
+    if (initial === undefined || initial === null) return;
+    const kind = initial instanceof Date ? "Date" : Array.isArray(initial) ? "array" : typeof initial;
+    if (raw.isKey === true) {
+      if (kind === "number" || kind === "bigint") return;
+      throw new ModelBuildError(
+        `Entity "${entityName}": key "${raw.propertyName}" has no column type and maps to an integer identity, but its initial value is a ${kind}. `
+          + `For a text key add @Column({ type: "text" }) next to @Key(); for a UUID key use @UUID().`,
+      );
+    }
+    if (kind === "string") return;
+    const suggestion = kind === "number" || kind === "bigint" ? `@Column({ type: "integer" }) or @Column({ type: "real" })`
+      : kind === "boolean" ? `@Column({ type: "boolean" })`
+      : kind === "Date" ? `@Column({ type: "datetime" })`
+      : `@Column({ type: "json" })`;
+    throw new ModelBuildError(
+      `Entity "${entityName}": property "${raw.propertyName}" has no column type and maps to text, but its initial value is a ${kind}. Set the type: ${suggestion}.`,
+    );
+  }
+
   private static buildProperty(entityName: string, raw: RawProperty): PropertyModel {
     const isKey = raw.isKey === true;
     const resolved = resolveColumnType(raw.type, isKey);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.98.13",
+  "version": "0.98.15",
   "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",