feat(@angular-devkit/core): add compileAsync to SchemaRegistry

Introduce promise based method to reduce RXJS usage and boiler-platting.

DEPRECATED: The Observable based `SchemaRegistry.compile` has been deprecated in favor of the Promise based `SchemaRegistry.compileAsync`.

Author: alan-agius4

goldens/public-api/angular_devkit/core/index.md

@@ -172,7 +172,9 @@ class CoreSchemaRegistry implements SchemaRegistry {
     addPreTransform(visitor: JsonVisitor, deps?: JsonVisitor[]): void;
     // (undocumented)
     addSmartDefaultProvider<T>(source: string, provider: SmartDefaultProvider<T>): void;
-    compile(schema: JsonSchema): Observable<SchemaValidator>;
+    // @deprecated
+    compile(schema: JsonSchema): Observable<SchemaValidatorObservable>;
+    compileAsync(schema: JsonSchema): Promise<SchemaValidator>;
     // @deprecated
     flatten(schema: JsonObject): Observable<JsonObject>;
     // (undocumented)
@@ -186,6 +188,8 @@ class CoreSchemaRegistry implements SchemaRegistry {
     usePromptProvider(provider: PromptProvider): void;
     // (undocumented)
     useXDeprecatedProvider(onUsage: (message: string) => void): void;
+    // (undocumented)
+    ɵflatten(schema: JsonObject): Promise<JsonObject>;
 }
 
 // @public (undocumented)
@@ -821,6 +825,7 @@ declare namespace schema {
         SchemaValidatorError,
         SchemaValidatorOptions,
         SchemaValidator,
+        SchemaValidatorObservable,
         SchemaFormatter,
         SchemaFormat,
         SmartDefaultProvider,
@@ -872,14 +877,18 @@ interface SchemaRegistry {
     addPreTransform(visitor: JsonVisitor, deps?: JsonVisitor[]): void;
     // (undocumented)
     addSmartDefaultProvider<T>(source: string, provider: SmartDefaultProvider<T>): void;
+    // @deprecated (undocumented)
+    compile(schema: Object): Observable<SchemaValidatorObservable>;
     // (undocumented)
-    compile(schema: Object): Observable<SchemaValidator>;
+    compileAsync(schema: Object): Promise<SchemaValidator>;
     // @deprecated (undocumented)
     flatten(schema: JsonObject | string): Observable<JsonObject>;
     // (undocumented)
     usePromptProvider(provider: PromptProvider): void;
     // (undocumented)
     useXDeprecatedProvider(onUsage: (message: string) => void): void;
+    // (undocumented)
+    ɵflatten(schema: JsonObject | string): Promise<JsonObject>;
 }
 
 // @public (undocumented)
@@ -894,12 +903,18 @@ class SchemaValidationException extends BaseException {
 // @public (undocumented)
 interface SchemaValidator {
     // (undocumented)
-    (data: JsonValue, options?: SchemaValidatorOptions): Observable<SchemaValidatorResult>;
+    (data: JsonValue, options?: SchemaValidatorOptions): Promise<SchemaValidatorResult>;
 }
 
 // @public (undocumented)
 type SchemaValidatorError = Partial<ErrorObject>;
 
+// @public @deprecated (undocumented)
+interface SchemaValidatorObservable {
+    // (undocumented)
+    (data: JsonValue, options?: SchemaValidatorOptions): Observable<SchemaValidatorResult>;
+}
+
 // @public (undocumented)
 interface SchemaValidatorOptions {
     // (undocumented)

packages/angular/cli/src/command-builder/utilities/json-schema.ts

@@ -7,7 +7,6 @@
  */
 
 import { json } from '@angular-devkit/core';
-import assert from 'node:assert';
 import yargs from 'yargs';
 
 /**
@@ -198,9 +197,7 @@ export async function parseJsonSchemaToOptions(
     options.push(option);
   }
 
-  const flattenedSchema = await registry.flatten(schema).toPromise();
-  // TODO(RXJS): temporary assert to avoid adding rxjs dependency.
-  assert(flattenedSchema);
+  const flattenedSchema = await registry.ɵflatten(schema);
   json.schema.visitJsonSchema(flattenedSchema, visitor);
 
   // Sort by positional and name.

packages/angular/cli/src/utilities/config.ts

@@ -8,7 +8,6 @@
 
 import { json, workspaces } from '@angular-devkit/core';
 import { existsSync, promises as fs } from 'fs';
-import assert from 'node:assert';
 import * as os from 'os';
 import * as path from 'path';
 import { PackageManager } from '../../lib/config/workspace-schema';
@@ -254,12 +253,8 @@ export async function validateWorkspace(data: json.JsonObject, isGlobal: boolean
 
   const { formats } = await import('@angular-devkit/schematics');
   const registry = new json.schema.CoreSchemaRegistry(formats.standardFormats);
-  const validator = await registry.compile(schemaToValidate).toPromise();
-  // TODO(RXJS): temporary assert to avoid adding rxjs dependency.
-  assert(validator);
-  const result = await validator(data).toPromise();
-  // TODO(RXJS): temporary assert to avoid adding rxjs dependency.
-  assert(result);
+  const validator = await registry.compileAsync(schemaToValidate);
+  const result = await validator(data);
   const { success, errors } = result;
   if (!success) {
     throw new json.schema.SchemaValidationException(errors);

packages/angular_devkit/architect/src/architect.ts

@@ -7,23 +7,14 @@
  */
 
 import { json, logging } from '@angular-devkit/core';
-import {
-  Observable,
-  firstValueFrom,
-  from,
-  lastValueFrom,
-  merge,
-  of,
-  onErrorResumeNext,
-} from 'rxjs';
+import { Observable, from, merge, of, onErrorResumeNext } from 'rxjs';
 import {
   concatMap,
   first,
   ignoreElements,
   last,
   map,
   shareReplay,
-  switchMap,
   takeUntil,
 } from 'rxjs/operators';
 import {
@@ -73,7 +64,7 @@ function _createJobHandlerFromBuilderInfo(
   function handler(argument: json.JsonObject, context: JobHandlerContext) {
     // Add input validation to the inbound bus.
     const inboundBusWithInputValidation = context.inboundBus.pipe(
-      concatMap((message) => {
+      concatMap(async (message) => {
         if (message.kind === JobInboundMessageKind.Input) {
           const v = message.value as BuilderInput;
           const options = {
@@ -82,20 +73,17 @@ function _createJobHandlerFromBuilderInfo(
           };
 
           // Validate v against the options schema.
-          return registry.compile(info.optionSchema).pipe(
-            concatMap((validation) => validation(options)),
-            map((validationResult: json.schema.SchemaValidatorResult) => {
-              const { data, success, errors } = validationResult;
-              if (success) {
-                return { ...v, options: data } as BuilderInput;
-              }
-
-              throw new json.schema.SchemaValidationException(errors);
-            }),
-            map((value) => ({ ...message, value })),
-          );
+          const validation = await registry.compileAsync(info.optionSchema);
+          const validationResult = await validation(options);
+          const { data, success, errors } = validationResult;
+
+          if (!success) {
+            throw new json.schema.SchemaValidationException(errors);
+          }
+
+          return { ...message, value: { ...v, options: data } } as JobInboundMessage<BuilderInput>;
         } else {
-          return of(message as JobInboundMessage<BuilderInput>);
+          return message as JobInboundMessage<BuilderInput>;
         }
       }),
       // Using a share replay because the job might be synchronously sending input, but
@@ -343,18 +331,14 @@ function _validateOptionsFactory(host: ArchitectHost, registry: json.schema.Sche
         throw new Error(`No builder info were found for builder ${JSON.stringify(builderName)}.`);
       }
 
-      return firstValueFrom(
-        registry.compile(builderInfo.optionSchema).pipe(
-          concatMap((validation) => validation(options)),
-          switchMap(({ data, success, errors }) => {
-            if (success) {
-              return of(data as json.JsonObject);
-            }
+      const validation = await registry.compileAsync(builderInfo.optionSchema);
+      const { data, success, errors } = await validation(options);
 
-            throw new json.schema.SchemaValidationException(errors);
-          }),
-        ),
-      );
+      if (!success) {
+        throw new json.schema.SchemaValidationException(errors);
+      }
+
+      return data as json.JsonObject;
     },
     {
       name: '..validateOptions',

packages/angular_devkit/architect/src/jobs/simple-scheduler.ts

@@ -65,9 +65,9 @@ export class JobOutputSchemaValidationError extends schema.SchemaValidationExcep
 interface JobHandlerWithExtra extends JobHandler<JsonValue, JsonValue, JsonValue> {
   jobDescription: JobDescription;
 
-  argumentV: Observable<schema.SchemaValidator>;
-  outputV: Observable<schema.SchemaValidator>;
-  inputV: Observable<schema.SchemaValidator>;
+  argumentV: Observable<schema.SchemaValidatorObservable>;
+  outputV: Observable<schema.SchemaValidatorObservable>;
+  inputV: Observable<schema.SchemaValidatorObservable>;
 }
 
 function _jobShare<T>(): MonoTypeOperatorFunction<T> {

packages/angular_devkit/build_angular/src/testing/builder-harness.ts

@@ -26,11 +26,11 @@ import {
   Observable,
   Subject,
   firstValueFrom,
-  lastValueFrom,
+  from,
   from as observableFrom,
   of as observableOf,
 } from 'rxjs';
-import { catchError, finalize, first, map, mergeMap, shareReplay } from 'rxjs/operators';
+import { catchError, finalize, map, mergeMap, shareReplay } from 'rxjs/operators';
 import { BuilderWatcherFactory, WatcherNotifier } from './file-watching';
 
 export interface BuilderHarnessExecutionResult<T extends BuilderOutput = BuilderOutput> {
@@ -214,8 +214,8 @@ export class BuilderHarness<T> {
           }
         }
 
-        const validator = await lastValueFrom(this.schemaRegistry.compile(schema ?? true));
-        const { data } = await lastValueFrom(validator(options));
+        const validator = await this.schemaRegistry.compileAsync(schema ?? true);
+        const { data } = await validator(options);
 
         return data as json.JsonObject;
       },
@@ -237,7 +237,7 @@ export class BuilderHarness<T> {
     const logs: logging.LogEntry[] = [];
     context.logger.subscribe((e) => logs.push(e));
 
-    return this.schemaRegistry.compile(this.builderInfo.optionSchema).pipe(
+    return from(this.schemaRegistry.compileAsync(this.builderInfo.optionSchema)).pipe(
       mergeMap((validator) => validator(targetOptions)),
       map((validationResult) => validationResult.data),
       mergeMap((data) =>

packages/angular_devkit/core/src/json/schema/interface.ts

@@ -28,6 +28,13 @@ export interface SchemaValidatorOptions {
 }
 
 export interface SchemaValidator {
+  (data: JsonValue, options?: SchemaValidatorOptions): Promise<SchemaValidatorResult>;
+}
+
+/**
+ * @deprecated since 15.2 use the SchemaValidator instead.
+ */
+export interface SchemaValidatorObservable {
   (data: JsonValue, options?: SchemaValidatorOptions): Observable<SchemaValidatorResult>;
 }
 
@@ -72,7 +79,15 @@ export type PromptProvider = (
 ) => ObservableInput<{ [id: string]: JsonValue }>;
 
 export interface SchemaRegistry {
-  compile(schema: Object): Observable<SchemaValidator>;
+  /**
+   * @deprecated since 15.2 use `compileAsync` instead.
+   */
+  compile(schema: Object): Observable<SchemaValidatorObservable>;
+
+  compileAsync(schema: Object): Promise<SchemaValidator>;
+
+  /** @private */
+  ɵflatten(schema: JsonObject | string): Promise<JsonObject>;
   /**
    * @deprecated since 11.2 without replacement.
    * Producing a flatten schema document does not in all cases produce a schema with identical behavior to the original.

packages/angular_devkit/core/src/json/schema/registry.ts

@@ -25,6 +25,7 @@ import {
   SchemaRegistry,
   SchemaValidator,
   SchemaValidatorError,
+  SchemaValidatorObservable,
   SchemaValidatorOptions,
   SchemaValidatorResult,
   SmartDefaultProvider,
@@ -231,6 +232,11 @@ export class CoreSchemaRegistry implements SchemaRegistry {
     return from(this._flatten(schema));
   }
 
+  /** @private */
+  ɵflatten(schema: JsonObject): Promise<JsonObject> {
+    return this._flatten(schema);
+  }
+
   private async _flatten(schema: JsonObject): Promise<JsonObject> {
     this._ajv.removeSchema(schema);
 
@@ -273,10 +279,23 @@ export class CoreSchemaRegistry implements SchemaRegistry {
    *
    * @param schema The schema to validate. If a string, will fetch the schema before compiling it
    * (using schema as a URI).
-   * @returns An Observable of the Validation function.
    */
-  compile(schema: JsonSchema): Observable<SchemaValidator> {
-    return from(this._compile(schema)).pipe(
+  async compileAsync(schema: JsonSchema): Promise<SchemaValidator> {
+    const validate = await this._compile(schema);
+
+    return (value, options) => validate(value, options);
+  }
+
+  /**
+   * Compile and return a validation function for the Schema.
+   *
+   * @param schema The schema to validate. If a string, will fetch the schema before compiling it
+   * (using schema as a URI).
+   *
+   * @deprecated since 15.2 use `compileAsync` instead.
+   */
+  compile(schema: JsonSchema): Observable<SchemaValidatorObservable> {
+    return from(this.compileAsync(schema)).pipe(
       map((validate) => (value, options) => from(validate(value, options))),
     );
   }