@angular-devkit/core#virtualFs TypeScript Examples

function createHost(tree: Tree): workspaces.WorkspaceHost {
  return {
    async readFile(path: string): Promise<string> {
      const data = tree.read(path);
      if (!data) {
        throw new Error('File not found.');
      }

      return virtualFs.fileBufferToString(data);
    },
    async writeFile(path: string, data: string): Promise<void> {
      return tree.overwrite(path, data);
    },
    async isDirectory(path: string): Promise<boolean> {
      // approximate a directory check
      return !tree.exists(path) && tree.getDir(path).subfiles.length > 0;
    },
    async isFile(path: string): Promise<boolean> {
      return tree.exists(path);
    }
  };
}

function createHost(tree: Tree): workspaces.WorkspaceHost {
  return {
    async readFile(path: string): Promise<string> {
      const data = tree.read(path);
      if (!data) {
        throw new SchematicsException('File not found.');
      }
      return virtualFs.fileBufferToString(data);
    },
    async writeFile(path: string, data: string): Promise<void> {
      return tree.overwrite(path, data);
    },
    async isDirectory(path: string): Promise<boolean> {
      return !tree.exists(path) && tree.getDir(path).subfiles.length > 0;
    },
    async isFile(path: string): Promise<boolean> {
      return tree.exists(path);
    },
  };
}

/* Below code reference is taken from Angular CLI project. 
  https://github.com/angular/angular-cli/blob/master/packages/schematics/angular/utility/workspace.ts

  These methods are not part of public APIs so we should not be referencing those methods.
  that's why added below method here.
*/

function createHost(tree: Tree): workspaces.WorkspaceHost {
    return {
        async readFile(path: string): Promise<string> {
            const data = tree.read(path);
            if (!data) {
                throw new SchematicsException('File not found.');
            }
            return virtualFs.fileBufferToString(data);
        },
        async writeFile(path: string, data: string): Promise<void> {
            return tree.overwrite(path, data);
        },
        async isDirectory(path: string): Promise<boolean> {
            return !tree.exists(path) && tree.getDir(path).subfiles.length > 0;
        },
        async isFile(path: string): Promise<boolean> {
            return tree.exists(path);
        },
    };
}

async run(options: {
    collectionName: string;
    schematicName: string;
    debug?: boolean;
    dryRun?: boolean;
    force?: boolean;
    allowPrivate?: boolean;
    argv?: string[];
    options?: {};
  }) {
    const {
      collectionName,
      schematicName,
      debug,
      dryRun,
      force,
      allowPrivate,
      argv = [],
      options: passedOptions = {}
    } = options;

    /** Create the DevKit Logger used through the CLI. */
    const logger = createConsoleLogger(true, process.stdout, process.stderr);

    /** Create a Virtual FS Host scoped to where the process is being run. **/
    const fsHost = new virtualFs.ScopedHost(
      new NodeJsSyncHost(),
      normalize(process.cwd())
    );

    /** Create the workflow that will be executed with this run. */
    const workflow = new NodeWorkflow(fsHost, { force, dryRun });

    // Indicate to the user when nothing has been done. This is automatically set to off when there's
    // a new DryRunEvent.
    let nothingDone = true;

    // Logging queue that receives all the messages to show the users. This only get shown when no
    // errors happened.
    let loggingQueue: string[] = [];
    let error = false;

    /**
     * Logs out dry run events.
     *
     * All events will always be executed here, in order of discovery. That means that an error would
     * be shown along other events when it happens. Since errors in workflows will stop the Observable
     * from completing successfully, we record any events other than errors, then on completion we
     * show them.
     *
     * This is a simple way to only show errors when an error occur.
     */
    workflow.reporter.subscribe((event: DryRunEvent) => {
      nothingDone = false;

      switch (event.kind) {
        case 'error':
          error = true;

          const desc =
            event.description == 'alreadyExist'
              ? 'already exists'
              : 'does not exist';
          logger.warn(`ERROR! ${event.path} ${desc}.`);
          break;
        case 'update':
          loggingQueue.push(tags.oneLine`
          ${terminal.white('UPDATE')} ${event.path} (${
            event.content.length
          } bytes)
        `);
          break;
        case 'create':
          loggingQueue.push(tags.oneLine`
          ${terminal.green('CREATE')} ${event.path} (${
            event.content.length
          } bytes)
        `);
          break;
        case 'delete':
          loggingQueue.push(`${terminal.yellow('DELETE')} ${event.path}`);
          break;
        case 'rename':
          loggingQueue.push(
            `${terminal.blue('RENAME')} ${event.path} => ${event.to}`
          );
          break;
      }
    });

    /**
     * Listen to lifecycle events of the workflow to flush the logs between each phases.
     */
    workflow.lifeCycle.subscribe(event => {
      if (event.kind == 'workflow-end' || event.kind == 'post-tasks-start') {
        if (!error) {
          // Flush the log queue and clean the error state.
          loggingQueue.forEach(log => logger.info(log));
        }

        loggingQueue = [];
        error = false;
      }
    });

    // Pass the rest of the arguments as the smart default "argv". Then delete it.
    workflow.registry.addSmartDefaultProvider('argv', (schema: JsonObject) => {
      if ('index' in schema) {
        return argv[Number(schema['index'])];
      } else {
        return argv;
      }
    });
    // delete parsedArgs._;

    // Add prompts.
    workflow.registry.usePromptProvider(this.createPromptProvider());

    /**
     *  Execute the workflow, which will report the dry run events, run the tasks, and complete
     *  after all is done.
     *
     *  The Observable returned will properly cancel the workflow if unsubscribed, error out if ANY
     *  step of the workflow failed (sink or task), with details included, and will only complete
     *  when everything is done.
     */
    try {
      await workflow
        .execute({
          collection: collectionName,
          schematic: schematicName,
          options: passedOptions,
          allowPrivate: allowPrivate,
          debug: debug,
          logger: logger
        })
        .toPromise();

      if (nothingDone) {
        logger.info('Nothing to be done.');
      }

      return 0;
    } catch (err) {
      if (err instanceof UnsuccessfulWorkflowExecution) {
        // "See above" because we already printed the error.
        logger.fatal('The Schematic workflow failed. See above.');
      } else if (debug) {
        logger.fatal('An error occured:\n' + err.stack);
      } else {
        logger.fatal(err.stack || err.message);
      }

      return 1;
    }
  }