bazis 0.112.0 → 0.114.0

package/core/di/errors/configurationError.ts

@@ -0,0 +1,21 @@
+import { DiError } from "./DiError";
+
+const CONFIGURATION_ERROR = Symbol.for("bazis.configurationError");
+
+/**
+ * Marks an error found in the application's declarations — a module, a
+ * connector, a config — as a configuration error: the start prints it as one
+ * `[bazis] configuration error` line instead of a stack. The error keeps its
+ * class; the same error is returned.
+ */
+export function markConfigurationError<T>(error: T): T {
+  if (error instanceof Error && !Object.prototype.hasOwnProperty.call(error, CONFIGURATION_ERROR)) {
+    Object.defineProperty(error, CONFIGURATION_ERROR, { value: true });
+  }
+  return error;
+}
+
+/** A DI error, or an error marked with {@link markConfigurationError}. */
+export function isConfigurationError(error: unknown): error is Error {
+  return error instanceof DiError || (error instanceof Error && (error as unknown as Record<symbol, unknown>)[CONFIGURATION_ERROR] === true);
+}

package/core/di/errors/index.ts

@@ -12,3 +12,4 @@ export { ProviderNotFoundError } from "./ProviderNotFoundError";
 export { ScopeDisposedError } from "./ScopeDisposedError";
 export { ScopedServiceFromRootError } from "./ScopedServiceFromRootError";
 export { ServiceValidationError } from "./ServiceValidationError";
+export { isConfigurationError, markConfigurationError } from "./configurationError";

package/core/di/index.ts

@@ -10,6 +10,8 @@ export {
   CircularDependencyError,
   ClassDependenciesMismatchError,
   DiError,
+  isConfigurationError,
+  markConfigurationError,
   InvalidProviderError,
   ModuleEncapsulationError,
   ModuleOwnedProviderConflictError,
@@ -35,6 +37,7 @@ export {
   registerModuleOwnedContributionValidator,
   registerModuleOwnedProviderContributor,
   expandModuleMetadata,
+  deferModuleDeclarationError,
   createModuleOwnedMetadataChannel,
   createModuleOwnedProviderChannel,
   scoped,

package/core/di/module/index.ts

@@ -6,6 +6,7 @@ export { ModuleRegistrar } from "./ModuleRegistrar";
 export {
   registerModuleMetadataExpander,
   expandModuleMetadata,
+  deferModuleDeclarationError,
   type ModuleMetadataExpander,
 } from "./moduleExtensions";
 export {

package/core/di/module/moduleExtensions.ts

@@ -1,3 +1,4 @@
+import { markConfigurationError } from "../errors/configurationError";
 import type { BazisModuleMetadata, BazisModuleRef } from "./types";
 
 /**
@@ -21,15 +22,37 @@ export function registerModuleMetadataExpander(expander: ModuleMetadataExpander)
   }
 }
 
+const declarationErrors = new WeakMap<object, unknown>();
+
+/**
+ * Keeps a problem found while a module was declared (a bad `@Infra` manifest,
+ * …) instead of throwing it at import time. The application reports it as a
+ * configuration error when it builds this module.
+ */
+export function deferModuleDeclarationError(moduleRef: object, error: unknown): void {
+  if (!declarationErrors.has(moduleRef)) {
+    declarationErrors.set(moduleRef, markConfigurationError(error));
+  }
+}
+
 /** Collects extra module refs contributed by registered expanders for a module. */
 export function expandModuleMetadata(metadata: BazisModuleMetadata): readonly BazisModuleRef[] {
+  if (declarationErrors.has(metadata)) {
+    throw declarationErrors.get(metadata);
+  }
   if (expanders.length === 0) {
     return [];
   }
   const extra: BazisModuleRef[] = [];
   for (let index = 0; index < expanders.length; index += 1) {
     const expander = expanders[index] as ModuleMetadataExpander;
-    extra.push(...expander(metadata));
+    try {
+      extra.push(...expander(metadata));
+    } catch (error) {
+      // A bad declarative key (`ormBazis` options, …) is a configuration
+      // problem of the module, not an application crash.
+      throw markConfigurationError(error);
+    }
   }
   return extra;
 }

package/core/di/module/moduleOwnedProviderContributors.ts

@@ -1,4 +1,4 @@
-import { ModuleOwnedProviderConflictError } from "../errors";
+import { markConfigurationError, ModuleOwnedProviderConflictError } from "../errors";
 import type { ServiceCollection } from "../ServiceCollection";
 import {
   isClassProvider,
@@ -380,7 +380,11 @@ export function applyModuleOwnedProviderContributors(
   };
 
   for (let index = 0; index < contributors.length; index += 1) {
-    (contributors[index] as ModuleOwnedProviderContributor)(metadata, context);
+    try {
+      (contributors[index] as ModuleOwnedProviderContributor)(metadata, context);
+    } catch (error) {
+      throw markConfigurationError(error);
+    }
   }
 }
 
@@ -404,6 +408,12 @@ export function validateModuleOwnedContributions(
     ): readonly ModuleOwnedMetadataContribution<TPayload>[] => store.getMetadata(channel),
   });
   for (let index = 0; index < validators.length; index += 1) {
-    (validators[index] as ModuleOwnedContributionValidator)(snapshot);
+    try {
+      (validators[index] as ModuleOwnedContributionValidator)(snapshot);
+    } catch (error) {
+      // Conflicting owned stores or connector tokens across modules are
+      // declaration problems: report them as configuration errors.
+      throw markConfigurationError(error);
+    }
   }
 }

package/core/grpc/decorators.ts

@@ -11,6 +11,8 @@ interface ControllerMetadata {
   service?: ServiceDefinition;
   methods: Map<string | symbol, string>;
   requestModels: Map<string | symbol, RequestModelClass>;
+  /** Declaration problems, reported by grpcControllerDefinition at start. */
+  problems: string[];
 }
 interface Carrier { [GRPC_META]?: ControllerMetadata }
 
@@ -18,7 +20,12 @@ function ownMetadata(metadata: object): ControllerMetadata {
   const carrier = metadata as Carrier;
   if (!Object.hasOwn(carrier, GRPC_META)) {
     const parent = carrier[GRPC_META];
-    carrier[GRPC_META] = { service: parent?.service, methods: new Map(parent?.methods), requestModels: new Map(parent?.requestModels) };
+    carrier[GRPC_META] = {
+      service: parent?.service,
+      methods: new Map(parent?.methods),
+      requestModels: new Map(parent?.requestModels),
+      problems: [...(parent?.problems ?? [])],
+    };
   }
   return carrier[GRPC_META]!;
 }
@@ -26,32 +33,44 @@ function ownMetadata(metadata: object): ControllerMetadata {
 /** Bind a controller to a generated codec definition or grpcService(). */
 export function GrpcController(service: ServiceDefinition) {
   return (_value: Class<object>, context: ClassDecoratorContext): void => {
+    const meta = ownMetadata(context.metadata);
     if (!service || typeof service !== "object" || Object.keys(service).length === 0) {
-      throw new TypeError("@GrpcController requires a non-empty gRPC service definition.");
+      meta.problems.push("@GrpcController requires a non-empty gRPC service definition.");
+      return;
     }
     const snapshot: Record<string, ServiceDefinition[string]> = Object.create(null);
     for (const [name, method] of Object.entries(service)) {
       if (!method || typeof method.path !== "string" || !/^\/[^/]+\/[^/]+$/.test(method.path)
         || typeof method.requestStream !== "boolean" || typeof method.responseStream !== "boolean"
         || typeof method.requestDeserialize !== "function" || typeof method.responseSerialize !== "function") {
-        throw new TypeError(`Invalid gRPC service method: ${name}.`);
+        meta.problems.push(`invalid gRPC service method: ${name}.`);
+        return;
       }
       snapshot[name] = Object.freeze({ ...method });
     }
-    ownMetadata(context.metadata).service = Object.freeze(snapshot);
+    meta.service = Object.freeze(snapshot);
   };
 }
 
 /** Request/response values for unary; AsyncIterable values for streaming sides. */
 export function GrpcMethod(rpcName?: string, requestModel?: RequestModelClass) {
-  if (requestModel !== undefined && (typeof requestModel !== "function" || !requestModel.prototype)) {
-    throw new TypeError("gRPC requestModel must be a DTO class.");
-  }
   return (_value: unknown, context: ClassMethodDecoratorContext): void => {
-    if (context.static || context.private) throw new TypeError("@GrpcMethod requires a public instance method.");
-    const name = rpcName ?? (typeof context.name === "string" ? context.name : "");
-    if (typeof name !== "string" || name.trim().length === 0) throw new TypeError("gRPC method name must not be empty.");
     const meta = ownMetadata(context.metadata);
+    // Problems are reported when the controller is registered, not at import.
+    const method = String(context.name);
+    if (requestModel !== undefined && (typeof requestModel !== "function" || !requestModel.prototype)) {
+      meta.problems.push(`${method}: gRPC requestModel must be a DTO class.`);
+      return;
+    }
+    if (context.static || context.private) {
+      meta.problems.push(`${method}: @GrpcMethod requires a public instance method.`);
+      return;
+    }
+    const name = rpcName ?? (typeof context.name === "string" ? context.name : "");
+    if (typeof name !== "string" || name.trim().length === 0) {
+      meta.problems.push(`${method}: gRPC method name must not be empty.`);
+      return;
+    }
     meta.methods.set(context.name, name);
     // A redecorated override must not silently retain the base method's DTO.
     if (requestModel === undefined) meta.requestModels.delete(context.name);
@@ -63,6 +82,8 @@ export function GrpcMethod(rpcName?: string, requestModel?: RequestModelClass) {
 export function grpcControllerDefinition(controller: Class<object>): GrpcControllerDefinition {
   const carrier = (controller as unknown as { [Symbol.metadata]?: Carrier })[Symbol.metadata];
   const meta = carrier?.[GRPC_META];
+  const problem = meta?.problems[0];
+  if (problem !== undefined) throw new GrpcSetupError(`${controller.name}: ${problem}`);
   if (!meta?.service) throw new GrpcSetupError(`${controller.name} must use @GrpcController().`);
   const methods = new Map<string, string | symbol>();
   for (const [methodName, rpcName] of meta.methods) {

package/core/infra/Infra.ts

@@ -4,6 +4,7 @@ import {
   Module,
   createToken,
   createModuleOwnedMetadataChannel,
+  deferModuleDeclarationError,
   registerModuleOwnedProviderContributor,
   registerModuleOwnedContributionValidator,
   type ModuleConfig,
@@ -14,6 +15,7 @@ import {
 import { ConfigRegistry, HEALTH_CHECK, StartupReport } from "../kernel";
 import { InfraError, type InfraConnector } from "./InfraConnector";
 import { InfraLifecycle } from "./InfraLifecycle";
+import { connectorDeclarationError } from "./connectorIdentity";
 
 /**
  * Infrastructure manifest: a readable "logical name → connector" map.
@@ -57,6 +59,8 @@ function buildInfraDefinitions(manifest: InfraManifest): {
   const seenTokens = new Map<InfraConnector["token"], string>();
 
   for (const [name, connector] of Object.entries(manifest)) {
+    const invalid = connectorDeclarationError(connector);
+    if (invalid !== undefined) throw invalid.error;
     if (!name.trim() || name !== name.trim()) throw new InfraError("Infra instance names must be non-empty and trimmed.");
     if (connector.phase !== undefined && !Number.isSafeInteger(connector.phase)) {
       throw new InfraError(`Infra instance "${name}": phase must be a finite safe integer.`);
@@ -135,8 +139,15 @@ function buildInfraDefinitions(manifest: InfraManifest): {
  * `@Infra`, but without a class. Handy for `imports` or `runApp({ infra })`.
  */
 export function infraModule(manifest: InfraManifest): BazisModuleRef {
-  const { providers, exports, config } = buildInfraDefinitions(manifest);
-  return { global: true, providers, exports, config };
+  try {
+    const { providers, exports, config } = buildInfraDefinitions(manifest);
+    return { global: true, providers, exports, config };
+  } catch (error) {
+    // Reported when the application is built, not while the file is imported.
+    const moduleRef: BazisModuleRef = { global: true };
+    deferModuleDeclarationError(moduleRef, error);
+    return moduleRef;
+  }
 }
 
 /**
@@ -157,8 +168,21 @@ export function infraModule(manifest: InfraManifest): BazisModuleRef {
  * ```
  */
 export function Infra(manifest: InfraManifest) {
-  const { providers, exports, config } = buildInfraDefinitions(manifest);
+  let definitions: ReturnType<typeof buildInfraDefinitions> | undefined;
+  let declarationError: unknown;
+  try {
+    definitions = buildInfraDefinitions(manifest);
+  } catch (error) {
+    declarationError = error;
+  }
   return (target: abstract new (...args: never) => unknown, _context: ClassDecoratorContext): void => {
+    if (definitions === undefined) {
+      // Reported when the application is built, not while the file is imported.
+      Module({ global: true })(target, _context);
+      deferModuleDeclarationError(target, declarationError);
+      return;
+    }
+    const { providers, exports, config } = definitions;
     Module({ global: true, providers, exports, config })(target, _context);
   };
 }

package/core/infra/connectorIdentity.ts

@@ -9,6 +9,31 @@ const lifecycles = new WeakMap<object, LifecycleBinding>();
 const values = (c: InfraConnector) => [c.token, c.config, c.phase, c.create, c.connect, c.dispose, c.healthCheck, c.providers, c.exports] as const;
 const unchanged = (c: InfraConnector, identity: ConnectorIdentity) => values(c).every((value, index) => Object.is(value, identity.fingerprint[index]));
 
+const declarationErrors = new WeakMap<object, unknown>();
+
+/**
+ * @internal A connector factory whose options are invalid returns a connector
+ * that carries the problem: `@Infra` reports it when the application is built
+ * instead of crashing the import of the manifest file.
+ */
+export function invalidConnector<T>(token: InfraConnector<T>["token"], error: unknown): InfraConnector<T> {
+  const connector: InfraConnector<T> = {
+    token,
+    create() {
+      throw error;
+    },
+    connect() {},
+    dispose() {},
+  };
+  declarationErrors.set(connector, error);
+  return connector;
+}
+
+/** @internal The declaration problem of a connector made by `invalidConnector`. */
+export function connectorDeclarationError(connector: InfraConnector): { readonly error: unknown } | undefined {
+  return declarationErrors.has(connector) ? { error: declarationErrors.get(connector) } : undefined;
+}
+
 /** @internal A factory identifies its original connector; copies inherit no identity. */
 export function identifyConnector<T>(connector: InfraConnector<T>, role: string): InfraConnector<T> {
   identities.set(connector, Object.freeze({ role, fingerprint: values(connector) }));

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.112.0" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.114.0" }, 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/infra/connectors/llmRouter.ts

@@ -12,7 +12,7 @@ import {
   type AgentModelResponse,
 } from "../../agent";
 import { InfraError, type InfraConnector } from "../InfraConnector";
-import { identifyConnector } from "../connectorIdentity";
+import { identifyConnector, invalidConnector } from "../connectorIdentity";
 import { redactSensitiveText } from "../../../library/redaction";
 import { awaitAbortable } from "../../kernel/internal/awaitAbortable";
 import {
@@ -422,9 +422,16 @@ export function llmRouter(
   profiles: Readonly<Record<string, LlmModelProfile>>,
   options: LlmRouterOptions = {},
 ): InfraConnector<AgentModelProvider> {
-  const entries = profileEntries(profiles);
-  const defaultProfile = defaultProfileName(entries, options);
-  ensureFallbacksValid(entries);
+  let entries: ReturnType<typeof profileEntries>;
+  let defaultProfile: string;
+  try {
+    entries = profileEntries(profiles);
+    defaultProfile = defaultProfileName(entries, options);
+    ensureFallbacksValid(entries);
+  } catch (error) {
+    // Reported by `@Infra` when the application is built, not at import.
+    return invalidConnector(AGENT_MODEL_PROVIDER, error);
+  }
   const configs = Object.freeze(Array.from(new Set(entries.map(([, profile]) => profile.config))));
 
   // The framework LLM connector, like llmConnect: it never touches the schema,

package/core/kernel/Bazis.ts

@@ -1,4 +1,4 @@
-import { DiError } from "../di";
+import { isConfigurationError } from "../di";
 import { Kernel } from "./Kernel";
 import { KernelBuilder, type RootModuleInput } from "./KernelBuilder";
 import { KernelError, ShutdownTimeoutError } from "./errors";
@@ -76,7 +76,7 @@ export class Bazis {
       // deserve the same friendly output as build-time ones.
       if (screen !== undefined) {
         screen.failed(error, kernel);
-      } else if (error instanceof DiError || error instanceof KernelError) {
+      } else if (error instanceof KernelError || isConfigurationError(error)) {
         console.error(`[bazis] configuration error: ${redactSensitiveText(error.message)}`);
       } else {
         console.error(`[bazis] application failed: ${formatStartupFailure(error)}`);
@@ -103,7 +103,7 @@ export function reportBuildFailure(
     process.exitCode = 1;
     return 1;
   }
-  if (error instanceof DiError || error instanceof KernelError) {
+  if (error instanceof KernelError || isConfigurationError(error)) {
     console.error(`[bazis] configuration error: ${redactSensitiveText(error.message)}`);
     process.exitCode = 1;
     return 1;

package/core/kernel/config/defineConfig.ts

@@ -30,11 +30,14 @@ export interface ConfigEnum<T extends string | number = string | number> {
   readonly default: T;
 }
 export function configEnum<const V extends readonly [string | number, ...(string | number)[]]>(values: V, defaultValue: V[number]): ConfigEnum<V[number]> {
+  const declared: ConfigEnum<V[number]> = Object.freeze({ __enum: true, values: Object.freeze([...values]), default: defaultValue });
   if (!values.length || !values.includes(defaultValue) || values.some(value => typeof value !== typeof defaultValue || (typeof value === "number" && !Number.isFinite(value)))) {
-    throw new KernelError("configEnum requires non-empty homogeneous finite values and a declared default.");
+    // defineConfig reports it at start, with the other configuration errors.
+    invalidEnums.set(declared, new KernelError("configEnum requires non-empty homogeneous finite values and a declared default."));
   }
-  return Object.freeze({ __enum: true, values: Object.freeze([...values]), default: defaultValue });
+  return declared;
 }
+const invalidEnums = new WeakMap<object, KernelError>();
 type Cell = Primitive | SecretSpec | ConfigEnum;
 type Defaults = Record<string, Cell>;
 export type ConfigValueType = Primitive | Secret;
@@ -119,7 +122,11 @@ function isSecret(cell: Cell): cell is SecretSpec { return typeof cell === "obje
 function isEnum(cell: Cell): cell is ConfigEnum { return typeof cell === "object" && cell !== null && "__enum" in cell; }
 function copyCell(cell: Cell): Cell {
   if (isSecret(cell)) return secret(cell.default);
-  if (isEnum(cell)) return Object.freeze({ ...cell, values: Object.freeze([...cell.values]) });
+  if (isEnum(cell)) {
+    const problem = invalidEnums.get(cell);
+    if (problem !== undefined) throw problem;
+    return Object.freeze({ ...cell, values: Object.freeze([...cell.values]) });
+  }
   if (["string", "number", "boolean"].includes(typeof cell)) return cell;
   throw new KernelError("Configuration supports only primitive values, secret() and configEnum().");
 }
@@ -141,6 +148,26 @@ export function defineConfig(prefixOrSchema: string | ConfigSchema<Defaults>, ma
   // The file that declared the config, for "declared in" of a startup failure.
   const declaredIn = callerFile(new Error().stack);
   const input = typeof prefixOrSchema === "string" ? maybeSchema! : prefixOrSchema;
+  let definition: ConfigDefinition<ConfigShape>;
+  try {
+    definition = createDefinition(prefix, input, declaredIn);
+  } catch (error) {
+    if (!(error instanceof KernelError)) throw error;
+    // A declaration problem is reported at start, with the other configuration
+    // errors, instead of crashing the import of the file that declares it.
+    const fail = (): never => { throw error; };
+    definition = Object.freeze({
+      token: Object.freeze(createToken<ConfigView<ConfigShape>>(`Config:${prefix || "default"}`)),
+      resolve: fail,
+      get: fail,
+      has: fail,
+      ensureValid: fail,
+    });
+  }
+  definitions.add(definition);
+  return definition;
+}
+function createDefinition(prefix: string, input: ConfigSchema<Defaults>, declaredIn: string | undefined): ConfigDefinition<ConfigShape> {
   const schema = Object.freeze({
     default: Object.freeze(Object.fromEntries(Object.entries(input.default).map(([key, value]) => [key, copyCell(value)]))),
     ...Object.fromEntries((["development", "test", "production"] as const).map(stand => [stand, Object.freeze(Object.fromEntries(Object.entries(input[stand] ?? {}).map(([key, value]) => [key, copyCell(value as Cell)])))])),
@@ -245,13 +272,11 @@ export function defineConfig(prefixOrSchema: string | ConfigSchema<Defaults>, ma
       inspect: () => rows,
     });
   };
-  const definition: ConfigDefinition<ConfigShape> = Object.freeze({
+  return Object.freeze({
     token: Object.freeze(createToken<ConfigView<ConfigShape>>(`Config:${prefix || "default"}`)),
     resolve,
     get: <K extends keyof ConfigShape>(key: K): ConfigShape[K] => resolve().get(key),
     has: <K extends keyof ConfigShape>(key: K) => resolve().has(key),
     ensureValid(environment?: Stand) { resolve(environment); },
   });
-  definitions.add(definition);
-  return definition;
 }

package/core/kernel/report/startupProblems.ts

@@ -1,4 +1,4 @@
-import { DiError } from "../../di";
+import { DiError, isConfigurationError } from "../../di";
 import { ServiceValidationError } from "../../di/errors/ServiceValidationError";
 import { redactSensitiveText } from "../../../library/redaction";
 import type { Problem, Screen } from "../../../library/terminal";
@@ -68,7 +68,7 @@ export function diagnoseStartupFailure(error: unknown, screen: Screen, context:
     };
   }
   const failed = context.failedServices?.[0];
-  const stage = error instanceof KernelError && failed === undefined ? "configuration" : stageOf(failed ?? "");
+  const stage = (error instanceof KernelError || isConfigurationError(error)) && failed === undefined ? "configuration" : stageOf(failed ?? "");
   return { stage, title: t.failure.app, problems: [genericProblem(error, failed)] };
 }
 

package/library/orm/Query/EntityQuery.ts

@@ -164,7 +164,7 @@ export class EntityQuery<T extends object, TResult = T> {
       result[i] = entity;
     }
     if (this.plan.includes.length > 0) {
-      await new IncludeLoader(this.runtime).load(this.model, result as object[], this.plan.includes, this.plan.noTracking);
+      await new IncludeLoader(this.runtime, this.plan.ignoreQueryFilters).load(this.model, result as object[], this.plan.includes, this.plan.noTracking);
     }
     return result as unknown as TResult[];
   }

package/library/orm/Query/IncludeLoader.ts

@@ -19,7 +19,11 @@ interface Level {
  * together in memory. This avoids the Cartesian product of collection JOINs.
  */
 export class IncludeLoader {
-  constructor(private readonly runtime: DbContextRuntime) {}
+  /**
+   * `ignoreQueryFilters` comes from the main query: when it turned the filters
+   * off, included entities are read without them too (as in EF Core).
+   */
+  constructor(private readonly runtime: DbContextRuntime, private readonly ignoreQueryFilters = false) {}
 
   async load(rootModel: EntityModel, roots: object[], paths: readonly (readonly string[])[], noTracking: boolean): Promise<void> {
     if (roots.length === 0) {
@@ -156,14 +160,19 @@ export class IncludeLoader {
     return model.key[0];
   }
 
+  private translator(model: EntityModel): SqlTranslator {
+    return new SqlTranslator(model, this.runtime.provider.dialect, this.ignoreQueryFilters ? [] : effectiveQueryFilters(model, this.runtime.context));
+  }
+
   private async queryIn(model: EntityModel, property: string, values: readonly unknown[], noTracking: boolean): Promise<object[]> {
-    const translator = new SqlTranslator(model, this.runtime.provider.dialect, effectiveQueryFilters(model, this.runtime.context));
+    const translator = this.translator(model);
     const result: object[] = [];
     const chunkSize = maxParametersPerInList(this.runtime.provider);
     for (let start = 0; start < values.length; start += chunkSize) {
       const chunk = values.slice(start, start + chunkSize);
       const { sql, params } = translator.selectAll({
         ...EMPTY_PLAN,
+        ignoreQueryFilters: this.ignoreQueryFilters,
         conditions: [{ kind: "in", property, values: chunk }],
         noTracking,
       });
@@ -181,7 +190,7 @@ export class IncludeLoader {
 
   private async queryTuples(model: EntityModel, properties: readonly string[], values: readonly (readonly unknown[])[], noTracking: boolean): Promise<object[]> {
     const result: object[] = []; const perTuple = properties.length; const chunkSize = Math.max(1, Math.floor(maxParametersPerInList(this.runtime.provider) / perTuple));
-    for (let start = 0; start < values.length; start += chunkSize) { const translator = new SqlTranslator(model, this.runtime.provider.dialect, effectiveQueryFilters(model, this.runtime.context)); const { sql, params } = translator.selectAll({ ...EMPTY_PLAN, conditions: [{ kind: "tuples", properties, values: values.slice(start, start + chunkSize) }], noTracking }); for (let entity of (await this.runtime.provider.query(sql, params)).map((row) => materialize<object>(model, row, this.runtime.provider.dialect))) { if (!noTracking) entity = this.runtime.tracker.trackLoaded(entity, model); result.push(entity); } }
+    for (let start = 0; start < values.length; start += chunkSize) { const translator = this.translator(model); const { sql, params } = translator.selectAll({ ...EMPTY_PLAN, ignoreQueryFilters: this.ignoreQueryFilters, conditions: [{ kind: "tuples", properties, values: values.slice(start, start + chunkSize) }], noTracking }); for (let entity of (await this.runtime.provider.query(sql, params)).map((row) => materialize<object>(model, row, this.runtime.provider.dialect))) { if (!noTracking) entity = this.runtime.tracker.trackLoaded(entity, model); result.push(entity); } }
     return result;
   }
   private tuple(model: EntityModel, values: readonly unknown[]): string | undefined {

package/package.json

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