Inspect schemas prior to constraining

src/compiler/bootstrap/impl/ucc-processor.constraint-application.ts

@@ -1,5 +1,4 @@
 import { UcProcessorName, UcSchemaConstraint } from '../../../schema/uc-constraints.js';
-import { ucModelName } from '../../../schema/uc-model-name.js';
 import { UcPresentationName } from '../../../schema/uc-presentations.js';
 import { UcSchema } from '../../../schema/uc-schema.js';
 import { UccBootstrap } from '../ucc-bootstrap.js';
@@ -15,19 +14,19 @@ export class UccProcessor$ConstraintApplication<
   readonly #featureSet: UccProcessor$FeatureSet<TBoot>;
   readonly #schema: UcSchema;
   readonly #issue: UccProcessor$ConstraintIssue<TOptions>;
-  readonly #feature: UccFeature<TBoot, TOptions>;
+  readonly #handle: UccFeature.Handle<TOptions>;
   #applied = 0;
 
   constructor(
     featureSet: UccProcessor$FeatureSet<TBoot>,
     schema: UcSchema,
     issue: UccProcessor$ConstraintIssue<TOptions>,
-    feature: UccFeature<TBoot, TOptions>,
+    handle: UccFeature.Handle<TOptions>,
   ) {
     this.#featureSet = featureSet;
     this.#schema = schema;
     this.#issue = issue;
-    this.#feature = feature;
+    this.#handle = handle;
   }
 
   get schema(): UcSchema {
@@ -68,16 +67,7 @@ export class UccProcessor$ConstraintApplication<
   }
 
   #constrain(): void {
-    const handle = this.#featureSet.enableFeature(this.#feature);
-    const { options } = this;
-
-    if (handle) {
-      this.#featureSet.runWithCurrent(this, () => handle.constrain(this));
-    } else if (options !== undefined) {
-      throw new TypeError(
-        `Feature ${this.#issue} can not constrain schema "${ucModelName(this.schema)}"`,
-      );
-    }
+    this.#featureSet.runWithCurrent(this, () => this.#handle.constrain(this));
   }
 
   ignore(): void {

src/compiler/bootstrap/impl/ucc-processor.constraint-issue.ts

@@ -1,8 +1,10 @@
 import { esQuoteKey, esStringLiteral } from 'esgen';
 import { UcProcessorName, UcSchemaConstraint } from '../../../schema/uc-constraints.js';
 import { UcPresentationName } from '../../../schema/uc-presentations.js';
+import { UcSchema } from '../../../schema/uc-schema.js';
 import { UccBootstrap } from '../ucc-bootstrap.js';
 import { UccFeature } from '../ucc-feature.js';
+import { UccProcessor$Current } from './ucc-processor.current.js';
 
 export class UccProcessor$ConstraintIssue<out TOptions> {
 
@@ -16,6 +18,12 @@ export class UccProcessor$ConstraintIssue<out TOptions> {
     return this.constraint.with as TOptions;
   }
 
+  toCurrent(schema: UcSchema): UccProcessor$Current {
+    const { processor, within, constraint } = this;
+
+    return { processor, schema, within, constraint };
+  }
+
   toString(): string {
     const { use, from } = this.constraint;
 
@@ -30,4 +38,5 @@ export interface UccProcessor$ConstraintResolution<
 > {
   readonly issue: UccProcessor$ConstraintIssue<TOptions>;
   readonly feature: UccFeature<TBoot, TOptions>;
+  readonly handle: UccFeature.Handle<TOptions>;
 }

src/compiler/bootstrap/impl/ucc-processor.constraint-usage.ts

@@ -1,3 +1,4 @@
+import { isPresent } from '@proc7ts/primitives';
 import { UcSchema } from '../../../schema/uc-schema.js';
 import { UccBootstrap } from '../ucc-bootstrap.js';
 import { UccProcessor$ConstraintApplication } from './ucc-processor.constraint-application.js';
@@ -15,6 +16,7 @@ export class UccProcessor$ConstraintUsage<
   readonly #featureSet: UccProcessor$FeatureSet<TBoot>;
   readonly #schema: UcSchema;
   readonly #issues: UccProcessor$ConstraintIssue<TOptions>[] = [];
+  #inspected = false;
 
   constructor(featureSet: UccProcessor$FeatureSet<TBoot>, schema: UcSchema) {
     this.#featureSet = featureSet;
@@ -27,31 +29,42 @@ export class UccProcessor$ConstraintUsage<
 
   async resolve(): Promise<() => void> {
     const featureSet = this.#featureSet;
-    const resolutions = await Promise.all(
-      this.#issues.map(async issue => await featureSet.resolveConstraint(issue)),
-    );
+    const resolutions = (
+      await Promise.all(
+        this.#issues.map(async issue => await featureSet.resolveConstraint(this.#schema, issue)),
+      )
+    ).filter(isPresent);
 
     this.#issues.length = 0;
 
     return () => {
+      this.#inspect(resolutions[0]);
+
       for (const resolution of resolutions) {
         this.#applyConstraint(resolution);
       }
     };
   }
 
-  #applyConstraint({ issue, feature }: UccProcessor$ConstraintResolution<TBoot, TOptions>): void {
+  #inspect(resolution: UccProcessor$ConstraintResolution<TBoot, TOptions> | undefined): void {
+    if (!this.#inspected && resolution) {
+      this.#inspected = true;
+      resolution.handle.inspect?.(this.#schema);
+    }
+  }
+
+  #applyConstraint({ issue, handle }: UccProcessor$ConstraintResolution<TBoot, TOptions>): void {
     const featureSet = this.#featureSet;
     const schema = this.#schema;
     const { processor, within, constraint } = issue;
-    const { constraintMapper: profiler } = featureSet;
-    const application = new UccProcessor$ConstraintApplication(featureSet, schema, issue, feature);
+    const { constraintMapper } = featureSet;
+    const application = new UccProcessor$ConstraintApplication(featureSet, schema, issue, handle);
 
-    featureSet.runWithCurrent({ processor, schema, within, constraint }, () => {
-      profiler.findHandler(processor, within, constraint)?.(application);
+    featureSet.runWithCurrent(issue.toCurrent(schema), () => {
+      constraintMapper.findHandler(processor, within, constraint)?.(application);
       if (within) {
         // Apply any presentation handler.
-        profiler.findHandler(processor, undefined, constraint)?.(application);
+        constraintMapper.findHandler(processor, undefined, constraint)?.(application);
       }
       if (!application.isIgnored()) {
         application.apply();

src/compiler/bootstrap/impl/ucc-processor.feature-set.ts

@@ -1,4 +1,6 @@
 import { lazyValue, mayHaveProperties } from '@proc7ts/primitives';
+import { ucModelName } from '../../../schema/uc-model-name.js';
+import { UcSchema } from '../../../schema/uc-schema.js';
 import { UccBootstrap } from '../ucc-bootstrap.js';
 import { UccFeature } from '../ucc-feature.js';
 import {
@@ -14,15 +16,17 @@ export class UccProcessor$FeatureSet<in out TBoot extends UccBootstrap<TBoot>> {
   readonly #resolutions = new Map<string, Promise<{ [key in string]: UccFeature<TBoot> }>>();
   readonly #enable: <TOptions>(
     feature: UccFeature<TBoot, TOptions>,
-  ) => UccFeature.Handle<TOptions> | void;
+  ) => UccFeature.Handle<TOptions> | undefined;
 
   readonly #features = new Map<UccFeature<TBoot, never>, UccFeature$Entry>();
 
   #current: UccProcessor$Current = {};
 
   constructor(
     constraintMapper: UccProcessor$ConstraintMapper<TBoot>,
-    enable: <TOptions>(feature: UccFeature<TBoot, TOptions>) => UccFeature.Handle<TOptions> | void,
+    enable: <TOptions>(
+      feature: UccFeature<TBoot, TOptions>,
+    ) => UccFeature.Handle<TOptions> | undefined,
   ) {
     this.#constraintMapper = constraintMapper;
     this.#enable = enable;
@@ -37,8 +41,9 @@ export class UccProcessor$FeatureSet<in out TBoot extends UccBootstrap<TBoot>> {
   }
 
   async resolveConstraint<TOptions>(
+    schema: UcSchema,
     issue: UccProcessor$ConstraintIssue<TOptions>,
-  ): Promise<UccProcessor$ConstraintResolution<TBoot, TOptions>> {
+  ): Promise<UccProcessor$ConstraintResolution<TBoot, TOptions> | undefined> {
     const {
       constraint: { use, from },
     } = issue;
@@ -49,10 +54,27 @@ export class UccProcessor$FeatureSet<in out TBoot extends UccBootstrap<TBoot>> {
       this.#resolutions.set(from, resolveFeatures);
     }
 
-    const { [use]: feature } = await resolveFeatures;
+    const { [use]: feature } = (await resolveFeatures) as {
+      [key in string]: UccFeature<TBoot, TOptions>;
+    };
 
     if ((mayHaveProperties(feature) && 'uccEnable' in feature) || typeof feature === 'function') {
-      return { issue, feature } as UccProcessor$ConstraintResolution<TBoot, TOptions>;
+      const handle: UccFeature.Handle<TOptions> | undefined = this.runWithCurrent(
+        issue.toCurrent(schema),
+        () => this.enableFeature(feature),
+      );
+
+      if (!handle && issue.constraint.with !== undefined) {
+        throw new TypeError(`Feature ${issue} can not constrain schema "${ucModelName(schema)}"`);
+      }
+
+      return (
+        handle && {
+          issue,
+          feature,
+          handle,
+        }
+      );
     }
     if (feature === undefined) {
       throw new ReferenceError(`No such schema processing feature: ${issue}`);
@@ -63,7 +85,7 @@ export class UccProcessor$FeatureSet<in out TBoot extends UccBootstrap<TBoot>> {
 
   enableFeature<TOptions>(
     feature: UccFeature<TBoot, TOptions>,
-  ): UccFeature.Handle<TOptions> | void {
+  ): UccFeature.Handle<TOptions> | undefined {
     let entry = this.#features.get(feature) as UccFeature$Entry<TOptions> | undefined;
 
     if (!entry) {
@@ -91,5 +113,5 @@ export class UccProcessor$FeatureSet<in out TBoot extends UccBootstrap<TBoot>> {
 }
 
 interface UccFeature$Entry<in TOptions = never> {
-  readonly getHandle: () => UccFeature.Handle<TOptions> | void;
+  readonly getHandle: () => UccFeature.Handle<TOptions> | undefined;
 }

src/compiler/bootstrap/ucc-feature.ts

@@ -53,6 +53,16 @@ export namespace UccFeature {
    * @typeParam TOptions - Type of supported schema constraint options.
    */
   export interface Handle<in TOptions = void> {
+    /**
+     * Inspects schema and {@link UccBootstrap#processSchema processes} its nested models, if any.
+     *
+     * When declared, this method is called at most once per schema and before any constraints applied. This may be
+     * necessary in order to {@link UccBootstrap#onConstraint override} constraints.
+     *
+     * @param schema - Target schema to decompose.
+     */
+    inspect?(schema: UcSchema): void;
+
     /**
      * Constrains the given schema with the given options.
      *

src/compiler/bootstrap/ucc-processor.ts

@@ -201,6 +201,10 @@ export abstract class UccProcessor<in out TBoot extends UccBootstrap<TBoot>>
    *
    * @returns Either feature handle, or nothing.
    */
+  protected handleFeature<TOptions>(
+    feature: UccFeature<TBoot, TOptions>,
+  ): UccFeature.Handle<TOptions> | undefined;
+
   protected handleFeature<TOptions>(
     feature: UccFeature<TBoot, TOptions>,
   ): UccFeature.Handle<TOptions> | void {

src/compiler/deserialization/list.ucrx.class.ts

@@ -35,10 +35,11 @@ export class ListUcrxClass<
     boot: TBoot,
   ): UccFeature.Handle<UccListOptions> {
     return {
+      inspect({ item }: UcList.Schema) {
+        boot.processModel(item);
+      },
       constrain: ({ schema, options }: UccFeature.Constraint<UccListOptions, UcList.Schema>) => {
-        boot
-          .processModel(schema.item)
-          .useUcrxClass(schema, (lib, schema: UcList.Schema) => new this(lib, schema, options));
+        boot.useUcrxClass(schema, (lib, schema: UcList.Schema) => new this(lib, schema, options));
       },
     };
   }

src/compiler/deserialization/map.ucrx.class.ts

@@ -36,17 +36,17 @@ export class MapUcrxClass<
     boot: TBoot,
   ): UccFeature.Handle<UcMap.Variant> {
     return {
-      constrain: ({ schema, options }: UccFeature.Constraint<UcMap.Variant, UcMap.Schema>) => {
-        const { entries, extra } = schema;
-
-        boot.useUcrxClass(schema, (lib, schema: UcMap.Schema) => new this(lib, schema, options));
+      inspect({ entries, extra }: UcMap.Schema) {
         for (const entrySchema of Object.values(entries)) {
           boot.processModel(entrySchema);
         }
         if (extra) {
           boot.processModel(extra);
         }
       },
+      constrain: ({ schema, options }: UccFeature.Constraint<UcMap.Variant, UcMap.Schema>) => {
+        boot.useUcrxClass(schema, (lib, schema: UcMap.Schema) => new this(lib, schema, options));
+      },
     };
   }
 

src/compiler/deserialization/ucd-compiler.ts

@@ -72,15 +72,15 @@ export class UcdCompiler<out TModels extends UcdModels = UcdModels>
 
   protected override handleFeature<TOptions>(
     feature: UccFeature<UcdBootstrap, TOptions>,
-  ): UccFeature.Handle<TOptions> | void {
+  ): UccFeature.Handle<TOptions> | undefined {
     if (feature === ucdProcessDefaults) {
       return this.#enableDefault();
     }
 
     return super.handleFeature(feature);
   }
 
-  #enableDefault(): void {
+  #enableDefault(): undefined {
     this.#entities.enableDefaults();
     this.#formats.enableDefaults();
     this.#meta.enableDefaults();

src/compiler/deserialization/unknown.ucrx.class.ts

@@ -26,11 +26,11 @@ export class UnknownUcrxClass extends UcrxClass {
 
   static uccEnable<TBoot extends UcrxBootstrap<TBoot>>(boot: TBoot): UccFeature.Handle {
     return {
-      constrain: ({ schema }) => {
-        boot
-          .useUcrxClass('unknown', (lib, schema) => new this(lib, schema))
-          .processModel(this.listSchemaFor(schema))
-          .processModel(this.mapSchemaFor(schema));
+      inspect: schema => {
+        boot.processModel(this.listSchemaFor(schema)).processModel(this.mapSchemaFor(schema));
+      },
+      constrain: _constraint => {
+        boot.useUcrxClass('unknown', (lib, schema) => new this(lib, schema));
       },
     };
   }

src/compiler/serialization/ucs-process-list.ts

@@ -14,8 +14,11 @@ import { UcsFormatterContext, UcsFormatterSignature } from './ucs-formatter.js';
 
 export function ucsProcessList(boot: UcsBootstrap): UccFeature.Handle<UccListOptions> {
   return {
+    inspect({ item }: UcList.Schema) {
+      boot.processModel(item);
+    },
     constrain({ schema, options }: UccFeature.Constraint<UccListOptions, UcList.Schema>) {
-      boot.processModel(schema.item).formatWith(
+      boot.formatWith(
         'charge',
         schema,
         ucsFormatCharge(

src/compiler/serialization/ucs-process-map.ts

@@ -25,14 +25,15 @@ export function ucsProcessMap(boot: UcsBootstrap): UccFeature.Handle {
   boot.formatWith('charge', 'map', ucsFormatCharge(ucsWriteMap));
 
   return {
-    constrain({ schema: { entries, extra } }: UccFeature.Constraint<void, UcMap.Schema>) {
+    inspect({ entries, extra }: UcMap.Schema) {
       Object.values(entries).forEach(entrySchema => boot.processModel(entrySchema));
       // istanbul ignore next
       if (extra) {
         // TODO Implement extra entries serialization.
         boot.processModel(extra);
       }
     },
+    constrain(_constraint) {},
   };
 }
 

src/syntax/formats/uri-params/uri-params.serializer.spec.ts

@@ -212,7 +212,6 @@ describe('URI params serializer', () => {
   });
   it('fails to serialize value in unknown inset format', async () => {
     const compiler = new UcsCompiler({
-      features: [ucsProcessDefaults, ucsProcessURIParams],
       models: {
         writeParams: {
           model: ucMap(
@@ -237,7 +236,6 @@ describe('URI params serializer', () => {
   });
   it('fails to serialize list item in unknown inset format', async () => {
     const compiler = new UcsCompiler({
-      features: [ucsProcessDefaults, ucsProcessURIParams],
       models: {
         writeParams: {
           model: ucMap(
@@ -320,7 +318,7 @@ describe('URI params serializer', () => {
 
     beforeAll(async () => {
       const compiler = new UcsCompiler({
-        features: [ucsProcessDefaults, ucsProcessURIEncoded, ucsProcessURIParams],
+        features: [ucsProcessDefaults, ucsProcessURIEncoded],
         models: {
           writeParams: {
             model: ucMap(
@@ -358,7 +356,7 @@ describe('URI params serializer', () => {
 
     beforeAll(async () => {
       const compiler = new UcsCompiler({
-        features: [ucsProcessDefaults, ucsProcessURIEncoded, ucsProcessURIParams],
+        features: [ucsProcessDefaults, ucsProcessURIEncoded],
         models: {
           writeParams: {
             model: ucMap(