bazis 0.120.0 → 0.121.0

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.120.0" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.121.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/library/validation/README.md

@@ -42,11 +42,12 @@ More scenarios (complex conditions, async, nested objects) are in
 
 | File | Purpose |
 |---|---|
-| `Validator.ts` | public facade: the decorator + `validate`/`validateAsync`/`setDefaultMessages` |
+| `Validator.ts` | public facade: the decorator + `validate`/`validateAsync`/`ruleSet`/`setDefaultMessages` |
 | `ValidationError.ts` | one error: `property`, `value`, `message`, `code` |
 | `ValidationResult.ts` | the outcome: `isValid`, `errors`, `getErrorsFor`, `hasErrorsFor` |
 | `RuleEngine.ts` | the engine: one pass over the plan, sync/async, nested, cycle protection |
 | `RuleCompiler.ts` | compiles class rules into a plan + WeakMap cache (RegExp, enum Set) |
+| `RuleSet.ts` | rules as data without a class: `Validator.ruleSet({ field: options })` |
 | `MessageRegistry.ts` | message templates, placeholders, priority local > global > built-in; built-in texts are English, `RU_VALIDATION_MESSAGES` is a Russian set for `setDefaults` and `runApp({ language: "ru" })` |
 | `metadata.ts` | stores rules through `context.metadata` / `Symbol.metadata` |
 | `types/ValidatorOptions.ts` | all decorator options |

package/library/validation/RuleCompiler.ts

@@ -1,4 +1,4 @@
-import { rulesOf } from "./metadata";
+import { rulesOf, type FieldRule } from "./metadata";
 import type { ValidatorOptions } from "./types/ValidatorOptions";
 
 /**
@@ -69,9 +69,18 @@ export class RuleCompiler {
     if (!rules) {
       return undefined;
     }
+    const plan = RuleCompiler.compileRules(rules);
+    RuleCompiler.cache.set(ctor, plan);
+    return plan;
+  }
+
+  /**
+   * Compiles a rule list that is not tied to a class (see `RuleSet`). Not
+   * cached: the caller keeps the result for as long as the rules are valid.
+   */
+  static compileRules(rules: readonly FieldRule[]): CompiledRule[] {
     const plan = rules.map((rule) => RuleCompiler.compile(rule.property, rule.options));
     RuleCompiler.assignNestedCarriers(plan);
-    RuleCompiler.cache.set(ctor, plan);
     return plan;
   }
 

package/library/validation/RuleEngine.ts

@@ -49,6 +49,24 @@ export class RuleEngine {
     return new ValidationResult(errors);
   }
 
+  /** Synchronous validation of any object by a precompiled plan (see `RuleSet`). */
+  static validatePlan(plan: readonly CompiledRule[], value: object): ValidationResult {
+    const errors: ValidationError[] = [];
+    RuleEngine.run(plan, value, "", errors, undefined, undefined);
+    return new ValidationResult(errors);
+  }
+
+  /** Asynchronous validation of any object by a precompiled plan (see `RuleSet`). */
+  static async validatePlanAsync(plan: readonly CompiledRule[], value: object): Promise<ValidationResult> {
+    const errors: ValidationError[] = [];
+    const jobs: AsyncJob[] = [];
+    RuleEngine.run(plan, value, "", errors, jobs, undefined);
+    for (const job of jobs) {
+      await job();
+    }
+    return new ValidationResult(errors);
+  }
+
   /**
    * Asynchronous validation: all synchronous rules run immediately, async
    * `custom` functions run sequentially after them (deterministic error order).
@@ -75,6 +93,17 @@ export class RuleEngine {
     if (!plan) {
       return;
     }
+    RuleEngine.run(plan, instance, prefix, errors, jobs, seen);
+  }
+
+  private static run(
+    plan: readonly CompiledRule[],
+    instance: object,
+    prefix: string,
+    errors: ValidationError[],
+    jobs: AsyncJob[] | undefined,
+    seen: Set<object> | undefined,
+  ): void {
     for (const rule of plan) {
       RuleEngine.applyRule(rule, instance, prefix, errors, jobs, seen);
     }

package/library/validation/RuleSet.ts

@@ -0,0 +1,59 @@
+import { RuleCompiler, type CompiledRule } from "./RuleCompiler";
+import { RuleEngine } from "./RuleEngine";
+import type { ValidationResult } from "./ValidationResult";
+import type { FieldRule } from "./metadata";
+import type { ValidatorOptions } from "./types/ValidatorOptions";
+
+/** Field rules of a {@link RuleSet}: one options object or several, as several decorators on one field. */
+export type FieldRules = Readonly<Record<string, ValidatorOptions | readonly ValidatorOptions[]>>;
+
+/**
+ * Validation rules that are data, not a decorated class: for objects whose
+ * shape is known only at run time (rows of tables created by users, rules
+ * stored in a database). The same engine, options, codes and messages as
+ * `@Validator`; the rules are compiled once in the constructor.
+ *
+ * ```ts
+ * const rules = Validator.ruleSet({
+ *   title: { required: true, maxLength: 200 },
+ *   amount: [{ type: "number", min: 0 }, { integer: true }],
+ * });
+ * rules.validate({ title: "", amount: -1.5 }).errors;
+ * ```
+ *
+ * Only the named fields are read. A field name that exists on
+ * `Object.prototype` (`__proto__`, `constructor`, `toString`…) is rejected,
+ * so a plain object never yields an inherited value.
+ */
+export class RuleSet {
+  private readonly plan: readonly CompiledRule[];
+
+  constructor(rules: FieldRules) {
+    const list: FieldRule[] = [];
+    for (const property of Object.keys(rules)) {
+      if (property in Object.prototype) {
+        throw new TypeError(`RuleSet: field "${property}" is not allowed: it is a property of Object.prototype.`);
+      }
+      const options = rules[property]!;
+      for (const item of Array.isArray(options) ? options as readonly ValidatorOptions[] : [options as ValidatorOptions]) {
+        list.push({ property, options: item });
+      }
+    }
+    this.plan = RuleCompiler.compileRules(list);
+  }
+
+  /** Field names that have rules. */
+  get fields(): readonly string[] {
+    return [...new Set(this.plan.map((rule) => rule.property))];
+  }
+
+  /** Synchronous validation; an async `custom` adds an `asyncCustomInSyncCall` error. */
+  validate(value: object): ValidationResult {
+    return RuleEngine.validatePlan(this.plan, value);
+  }
+
+  /** Asynchronous validation: awaits async `custom` functions. */
+  validateAsync(value: object): Promise<ValidationResult> {
+    return RuleEngine.validatePlanAsync(this.plan, value);
+  }
+}

package/library/validation/SPEC.md

@@ -412,6 +412,34 @@ Validator.validate(new ChildDto());  // checks both id and extra
 Validator.validate(new BaseDto());   // only id
 ```
 
+### 4.13 Rules as data: `Validator.ruleSet`
+
+When the fields are known only at run time (a table created by a user, rules
+stored in a database), there is no class to decorate. `Validator.ruleSet`
+takes the same options per field name and compiles them once:
+
+```ts
+const rules = Validator.ruleSet({
+  title: { required: true, maxLength: 200 },
+  amount: [{ type: "number", min: 0 }, { integer: true }],   // like two decorators
+});
+
+rules.validate({ title: "", amount: -1.5 }).errors;
+// [amount: min, amount: integer] — "" is a value, so required passes
+await rules.validateAsync(row);   // when a rule has an async custom
+rules.fields;                     // ["title", "amount"]
+```
+
+- Codes, paths, `params` and messages are the same as with `@Validator`.
+- The plan is compiled in the constructor (RegExp, enum Set) and not cached
+  globally: keep the `RuleSet` while the rules are valid and build a new one
+  when they change.
+- Only the named fields are read. A field name that exists on
+  `Object.prototype` (`__proto__`, `constructor`, `toString`…) throws
+  `TypeError`, so a plain object never yields an inherited value.
+- `nested: true` validates a nested value only if it is an instance of a
+  decorated class, as with decorators.
+
 ---
 
 ## 5. Result: `ValidationResult` and `ValidationError`

package/library/validation/Validator.ts

@@ -1,5 +1,6 @@
 import { MessageRegistry } from "./MessageRegistry";
 import { RuleEngine } from "./RuleEngine";
+import { RuleSet, type FieldRules } from "./RuleSet";
 import type { ValidationResult } from "./ValidationResult";
 import { registerFieldRule } from "./metadata";
 import type { ValidatorOptions } from "./types/ValidatorOptions";
@@ -74,6 +75,18 @@ export const Validator = Object.assign(
     validateAsync(instance: object): Promise<ValidationResult> {
       return RuleEngine.validateAsync(instance);
     },
+    /**
+     * Rules as data, without a class: for objects whose fields are known only
+     * at run time. Compiled once; keep the result and reuse it.
+     *
+     * ```ts
+     * const rules = Validator.ruleSet({ title: { required: true, maxLength: 200 } });
+     * rules.validate(row).isValid;
+     * ```
+     */
+    ruleSet(rules: FieldRules): RuleSet {
+      return new RuleSet(rules);
+    },
 
     /**
      * Globally overrides the standard error messages.

package/library/validation/index.ts

@@ -8,6 +8,7 @@
  * methods `validate` / `validateAsync` / `setDefaultMessages`.
  */
 export { Validator } from "./Validator";
+export { RuleSet, type FieldRules } from "./RuleSet";
 export { modelValidatorAdapter } from "./modelValidatorAdapter";
 export { ValidationError } from "./ValidationError";
 export { ValidationResult } from "./ValidationResult";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.120.0",
+  "version": "0.121.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",