Function execute

packages/angular_devkit/schematics/src/workflow/base.ts:146–213

(
    options: Partial<WorkflowExecutionContext> & RequiredWorkflowExecutionContext,
  )

  }

  execute(
    options: Partial<WorkflowExecutionContext> & RequiredWorkflowExecutionContext,
  ): Observable<void> {
    const parentContext = this._context.at(-1);

    if (!parentContext) {
      this._lifeCycle.next({ kind: 'start' });
    }

    /** Create the collection and the schematic. */
    const collection = this._engine.createCollection(options.collection);
    // Only allow private schematics if called from the same collection.
    const allowPrivate =
      options.allowPrivate || (parentContext && parentContext.collection === options.collection);
    const schematic = collection.createSchematic(options.schematic, allowPrivate);

    const sinks = this._createSinks();

    this._lifeCycle.next({ kind: 'workflow-start' });

    const context = {
      ...options,
      debug: options.debug || false,
      logger: options.logger || (parentContext && parentContext.logger) || new logging.NullLogger(),
      parentContext,
    };
    this._context.push(context);

    return schematic
      .call(options.options, of(new HostTree(this._host)), { logger: context.logger })
      .pipe(
        concatMap((tree: Tree) => {
          // Process all sinks.
          return concat(
            from(sinks).pipe(
              concatMap((sink) => sink.commit(tree)),
              ignoreElements(),
            ),
            of(tree),
          );
        }),
        concatMap(() => {
          if (this._dryRun) {
            return EMPTY;
          }

          this._lifeCycle.next({ kind: 'post-tasks-start' });

          return this._engine
            .executePostTasks()
            .pipe(
              tap({ complete: () => this._lifeCycle.next({ kind: 'post-tasks-end' }) }),
              defaultIfEmpty(undefined),
              last(),
            );
        }),
        tap({
          complete: () => {