bazis 0.98.15 → 0.98.16

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.15" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.98.16" }, 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/orm-predicate-codegen.ts

@@ -1,3 +1,4 @@
+import path from "node:path";
 import ts from "typescript";
 
 /** Reject JS truthiness where the caller is constructing an ORM condition. */
@@ -11,8 +12,11 @@ export function analyzeOrmPredicates(checker: ts.TypeChecker, source: ts.SourceF
   };
   const reject = (node: ts.Node): void => {
     const location = source.getLineAndCharacterOfPosition(node.getStart(source));
-    diagnostics.push(`BAZIS_ORM_PREDICATE_LOGIC: ${source.fileName}:${location.line + 1}:${location.character + 1}: `
-      + "ORM conditions cannot use JavaScript truthiness. Use .and(), .or(), .not() or an explicit boolean condition.");
+    // Relative like the other codegen diagnostics: the project path is noise.
+    const fileName = (path.isAbsolute(source.fileName) ? path.relative(".", source.fileName) : source.fileName).replaceAll("\\", "/");
+    diagnostics.push(`BAZIS_ORM_PREDICATE_LOGIC: ${fileName}:${location.line + 1}:${location.character + 1}: `
+      + "ORM conditions cannot use JavaScript truthiness: JavaScript keeps only one side of && and ||. "
+      + "Use .and(), .or(), .not(): (p) => p.views.gt(70).and(p.authorId.eq(2)).");
   };
   const visit = (node: ts.Node): void => {
     if (ts.isBinaryExpression(node)

package/library/orm/Metadata/decorators.ts

@@ -1,6 +1,6 @@
 import type { ColumnOptionsType, RelationKind, PropertyConvention } from "./types";
 import type { ValueConverter } from "./ValueConverter";
-import { fieldSelector, type PredicateFn } from "../Query/conditions";
+import { evaluatePredicate, type PredicateFn } from "../Query/conditions";
 import type { Condition } from "../Query/conditions";
 import { compileCheck, type CheckPredicate } from "../Schema/CheckExpression";
 
@@ -371,7 +371,7 @@ export function HasConversion(converter: ValueConverter) {
 export function QueryFilter<T extends object>(predicate: PredicateFn<T>) {
   return (_value: abstract new (...args: never[]) => unknown, context: ClassDecoratorContext): void => {
     const raw = ownRaw(context.metadata);
-    const node = predicate(fieldSelector<T>()).node;
+    const node = evaluatePredicate(predicate, "@QueryFilter").node;
     raw.queryFilters = [...(raw.queryFilters ?? []), node];
   };
 }

package/library/orm/Query/EntityQuery.ts

@@ -1,7 +1,7 @@
 import { EntityNotFoundError } from "../errors";
 import type { EntityModel } from "../Metadata/types";
 import type { DbContextRuntime } from "../runtime";
-import { fieldSelector, type KeySelectorFn, type PredicateFn } from "./conditions";
+import { evaluatePredicate, fieldSelector, type KeySelectorFn, type PredicateFn } from "./conditions";
 import { IncludeLoader } from "./IncludeLoader";
 import { materialize, materializeProjection } from "./materialize";
 import { EMPTY_PLAN, withCondition, withOrder, type QueryPlan } from "./QueryPlan";
@@ -30,6 +30,16 @@ function captureNavigation<T>(selector: (entity: T) => unknown): string {
   return captured;
 }
 
+const SELECT_HINT = "select() maps properties as they are, e.g. (p) => ({ name: p.title }); compute values after toList().";
+
+/** A property read inside `select`; turning it into a string or number is a computation select cannot translate. */
+class ProjectedField {
+  constructor(readonly property: string) {}
+  [Symbol.toPrimitive](): never {
+    throw new TypeError(SELECT_HINT);
+  }
+}
+
 /** Captures the `.select(u => ({ alias: u.prop }))` projection. */
 function captureProjection<T, R extends Record<string, unknown>>(
   selector: (entity: T) => R,
@@ -37,13 +47,16 @@ function captureProjection<T, R extends Record<string, unknown>>(
   const proxy = new Proxy(
     {},
     {
-      get(_target, property): string {
-        return String(property);
+      get(_target, property): ProjectedField {
+        return new ProjectedField(String(property));
       },
     },
   );
   const mapped = selector(proxy as T);
-  return Object.entries(mapped).map(([alias, propertyName]) => ({ alias, property: String(propertyName) }));
+  return Object.entries(mapped).map(([alias, field]) => {
+    if (!(field instanceof ProjectedField)) throw new TypeError(`${SELECT_HINT} "${alias}" is not a property.`);
+    return { alias, property: field.property };
+  });
 }
 
 /**
@@ -64,7 +77,7 @@ export class EntityQuery<T extends object, TResult = T> {
 
   /** Filter. Several calls are combined with AND. */
   where(predicate: PredicateFn<T>): EntityQuery<T, TResult> {
-    const result = predicate(fieldSelector<T>());
+    const result = evaluatePredicate(predicate, "where");
     return this.derive(withCondition(this.plan, result.node));
   }
 

package/library/orm/Query/ImmediateMutations.ts

@@ -143,7 +143,7 @@ function cloneCondition(model: EntityModel, input: unknown, active: Set<object>,
   const exact = (...keys: string[]) => { if (fields.size !== keys.length || keys.some((key) => !fields.has(key))) unsafe(); };
   const property = () => { const value = fields.get("property")?.value; if (typeof value !== "string" || !model.propertyByName(value)) unsafe(); return value; };
   let result: Condition;
-  if (kind === "compare") { const escaped = fields.get("escaped")?.value; if (escaped !== undefined && escaped !== true) unsafe(); exact(...(escaped === undefined ? ["kind", "property", "op", "value"] : ["kind", "property", "op", "value", "escaped"])); const op = fields.get("op")!.value; if (typeof op !== "string" || !["=", "<>", ">", ">=", "<", "<=", "LIKE"].includes(op) || (escaped === true && op !== "LIKE")) unsafe(); result = Object.freeze({ kind: "compare", property: property(), op: op as never, value: snapshot(fields.get("value")!.value, new Set(), new WeakMap(), true), ...(escaped === true ? { escaped: true } : {}) }); }
+  if (kind === "compare") { const escaped = fields.get("escaped")?.value; if (escaped !== undefined && escaped !== true) unsafe(); exact(...(escaped === undefined ? ["kind", "property", "op", "value"] : ["kind", "property", "op", "value", "escaped"])); const op = fields.get("op")!.value; if (typeof op !== "string" || !["=", "<>", ">", ">=", "<", "<=", "LIKE", "ILIKE"].includes(op) || (escaped === true && op !== "LIKE" && op !== "ILIKE")) unsafe(); result = Object.freeze({ kind: "compare", property: property(), op: op as never, value: snapshot(fields.get("value")!.value, new Set(), new WeakMap(), true), ...(escaped === true ? { escaped: true } : {}) }); }
   else if (kind === "in") { exact("kind", "property", "values"); result = Object.freeze({ kind: "in", property: property(), values: denseValues(fields.get("values")!.value) }); }
   else if (kind === "tuples") { exact("kind", "properties", "values"); const properties = denseValues(fields.get("properties")!.value); if (properties.some((value) => typeof value !== "string" || !model.propertyByName(value as string))) unsafe(); const rows = denseValues(fields.get("values")!.value).map((row) => { const values = denseValues(row); if (values.length !== properties.length) unsafe(); return Object.freeze(values); }); result = Object.freeze({ kind: "tuples", properties: Object.freeze(properties as string[]), values: Object.freeze(rows) }); }
   else if (kind === "null") { exact("kind", "property", "negated"); const negated = fields.get("negated")!.value; if (typeof negated !== "boolean") unsafe(); result = Object.freeze({ kind: "null", property: property(), negated }); }

package/library/orm/Query/conditions.ts

@@ -6,10 +6,17 @@
  * returns a column operand, comparison methods produce AST nodes, and
  * `.and()/.or()/.not()` combine them. No user strings in the SQL, only parameters.
  *
- * Note: `&&`/`||` are not intercepted; use `.and()/.or()`.
+ * Note: `&&`/`||` are not intercepted; use `.and()/.or()`. Codegen rejects
+ * them in where/count/any/first/firstOrDefault and @QueryFilter, and a result
+ * that is not a Predicate fails with a hint (see {@link evaluatePredicate}).
  */
 
-export type CompareOp = "=" | "<>" | ">" | ">=" | "<" | "<=" | "LIKE";
+export type CompareOp = "=" | "<>" | ">" | ">=" | "<" | "<=" | "LIKE" | "ILIKE";
+
+/** Text match options: `ignoreCase` compares case-insensitively (PostgreSQL `ILIKE`). */
+export interface TextMatchOptions {
+  readonly ignoreCase?: boolean;
+}
 
 export type Condition =
   | {
@@ -17,7 +24,7 @@ export type Condition =
       readonly property: string;
       readonly op: CompareOp;
       readonly value: unknown;
-      /** For LIKE from startsWith/endsWith/contains: add `ESCAPE '\'`. */
+      /** For LIKE/ILIKE from startsWith/endsWith/contains/eq: add `ESCAPE '\'`. */
       readonly escaped?: boolean;
     }
   | { readonly kind: "in"; readonly property: string; readonly values: readonly unknown[] }
@@ -49,12 +56,17 @@ export class Operand<T = unknown> {
     return new Predicate({ kind: "compare", property: this.property, op, value });
   }
 
-  /** LIKE with escaped wildcards (needs `ESCAPE '\'` in SQL). */
-  private likeEscaped(pattern: string): Predicate {
-    return new Predicate({ kind: "compare", property: this.property, op: "LIKE", value: pattern, escaped: true });
+  /** LIKE/ILIKE with escaped wildcards (needs `ESCAPE '\'` in SQL). */
+  private likeEscaped(pattern: string, options: TextMatchOptions | undefined): Predicate {
+    return new Predicate({ kind: "compare", property: this.property, op: options?.ignoreCase === true ? "ILIKE" : "LIKE", value: pattern, escaped: true });
   }
 
-  eq(value: T): Predicate {
+  /** Equality; `{ ignoreCase: true }` compares strings case-insensitively. */
+  eq(value: T, options?: TextMatchOptions): Predicate {
+    if (options?.ignoreCase === true) {
+      if (typeof value !== "string") throw new TypeError(`eq(..., { ignoreCase: true }) on "${this.property}" needs a string value.`);
+      return this.likeEscaped(escapeLike(value), options);
+    }
     return value === null ? this.isNull() : this.compare("=", value);
   }
   ne(value: T): Predicate {
@@ -75,14 +87,14 @@ export class Operand<T = unknown> {
   like(pattern: TextValue<T>): Predicate {
     return this.compare("LIKE", pattern);
   }
-  startsWith(value: TextValue<T>): Predicate {
-    return this.likeEscaped(`${escapeLike(value)}%`);
+  startsWith(value: TextValue<T>, options?: TextMatchOptions): Predicate {
+    return this.likeEscaped(`${escapeLike(value)}%`, options);
   }
-  endsWith(value: TextValue<T>): Predicate {
-    return this.likeEscaped(`%${escapeLike(value)}`);
+  endsWith(value: TextValue<T>, options?: TextMatchOptions): Predicate {
+    return this.likeEscaped(`%${escapeLike(value)}`, options);
   }
-  contains(value: TextValue<T>): Predicate {
-    return this.likeEscaped(`%${escapeLike(value)}%`);
+  contains(value: TextValue<T>, options?: TextMatchOptions): Predicate {
+    return this.likeEscaped(`%${escapeLike(value)}%`, options);
   }
   in(values: readonly T[]): Predicate {
     return new Predicate({ kind: "in", property: this.property, values: [...values] });
@@ -125,3 +137,17 @@ const FIELD_PROXY: ProxyHandler<object> = {
 export function fieldSelector<T>(): FieldSelector<T> {
   return new Proxy({}, FIELD_PROXY) as FieldSelector<T>;
 }
+
+/**
+ * Runs a predicate function and checks that it built a condition. `>`/`===`
+ * on an operand yield a boolean, and `cond && other` with a false left side
+ * yields `false`; without this check the query failed deep in SQL building.
+ */
+export function evaluatePredicate<T>(predicate: PredicateFn<T>, method: string): Predicate {
+  const result: unknown = predicate(fieldSelector<T>());
+  if (result instanceof Predicate) return result;
+  throw new TypeError(
+    `${method}() expects a condition such as (p) => p.views.gt(70), got ${result === null ? "null" : typeof result}. `
+      + "Use .gt()/.eq()/.and()/.or() instead of >, ===, &&, ||.",
+  );
+}

package/package.json

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