@zthun/romulator-api 1.6.0 → 1.7.0

package/dist/files/files-service.d.mts

@@ -1,20 +1,96 @@
-import { IZFileSystemNode } from '@zthun/crumbtrail-fs';
+import { IZFileRepository, IZFileSystemNode, IZFileSystemService } from '@zthun/crumbtrail-fs';
 import { IZRomulatorConfigsService } from '../config/configs-service.mjs';
 export declare const ZRomulatorFilesToken: unique symbol;
+/**
+ * Represents the service that you can use to
+ * scan the games folder for media, info, games, and systems.
+ */
 export interface IZRomulatorFilesService {
+    /**
+     * Retrieves all media found in the games .media folder.
+     *
+     * @returns
+     *        A list of all media found in the game media folder.
+     */
     media(): Promise<IZFileSystemNode[]>;
+    /**
+     * Retrieves a single media node found in the .media folder.
+     *
+     * @param path -
+     *        The path of the media node to retrieve.  This will
+     *        be relative to the configured games directory.  If this
+     *        starts with a root OS folder, then the path by itself
+     *        is used.
+     *
+     * @returns
+     *        The node with the given path or null if no such
+     *        file exists.
+     */
+    media(path: string): Promise<IZFileSystemNode | null>;
+    /**
+     * Retrieves all systems found in the games folder.
+     *
+     * A system is a root folder that is a slug of a supported
+     * system.
+     *
+     * @returns
+     *        A list of all systems found in the games folder.
+     */
+    systems(): Promise<IZFileSystemNode[]>;
+    /**
+     * Retrieves a single system found in the games folder.
+     *
+     * @param path -
+     *        The id of the system, which is also the name of the folder.
+     *
+     * @returns
+     *        The node that represents the system slug.  Returns null if
+     *        the folder does not exist or is not supported.  Note
+     *        that the path is relative to the configured games folder. If you
+     *        want to supply a fully qualified absolute path, then this string
+     *        should start with the root of an OS drive (not recommended).
+     */
+    systems(path: string): Promise<IZFileSystemNode | null>;
+    /**
+     * Retrieves all info found in the games .info folder.
+     *
+     * Info is the metadata scraped from a scraper service.
+     * The data format is stored in json.
+     *
+     * @returns
+     *        A list of all info found in the games folder.
+     */
+    info(): Promise<IZFileSystemNode[]>;
+    /**
+     * Retrieves specific information found in the games .info folder.
+     *
+     * @param path -
+     *        The path of the info node to retrieve.
+     *
+     * @returns
+     *        The node with the given path or null if no such file exists.
+     */
+    info(path: string): Promise<IZFileSystemNode | null>;
 }
 export declare class ZRomulatorFilesService implements IZRomulatorFilesService {
     private readonly _configs;
+    private readonly _fileSystem;
     private static readonly MediaFolderName;
     private static readonly InfoFolderName;
     private _repository;
-    private _folderWriter;
+    private _folderStream;
     private _globs;
-    constructor(_configs: IZRomulatorConfigsService);
+    private _systems;
+    constructor(_configs: IZRomulatorConfigsService, _fileSystem: IZFileSystemService);
     private gamesFolder;
     private mediaFolder;
     private infoFolder;
-    private repository;
+    private contents;
+    seed(): Promise<IZFileRepository>;
     media(): Promise<IZFileSystemNode[]>;
+    media(path: string): Promise<IZFileSystemNode | null>;
+    systems(): Promise<IZFileSystemNode[]>;
+    systems(path: string): Promise<IZFileSystemNode | null>;
+    info(): Promise<IZFileSystemNode[]>;
+    info(path: string): Promise<IZFileSystemNode | null>;
 }

package/dist/main.cjs

@@ -631,19 +631,24 @@ function _ts_param$4(paramIndex, decorator) {
 const ZRomulatorFilesToken = Symbol("files");
 class ZRomulatorFilesService {
     _configs;
+    _fileSystem;
     static MediaFolderName = ".media";
     static InfoFolderName = ".info";
     _repository = new crumbtrailFs.ZFileRepository();
-    _folderWriter = new crumbtrailFs.ZStreamFolder();
+    _folderStream = new crumbtrailFs.ZStreamFolder();
     _globs;
-    constructor(_configs){
+    _systems;
+    constructor(_configs, _fileSystem){
         this._configs = _configs;
+        this._fileSystem = _fileSystem;
         const slugs = Object.values(romulatorClient.ZRomulatorSystemId);
         this._globs = [
             ".media/**",
             ".info/**",
             ...slugs.map((s)=>`${s}/*.*`)
         ];
+        this._systems = Object.values(romulatorClient.ZRomulatorSystemId);
+        this.seed();
     }
     async gamesFolder() {
         const config = await this._configs.get(romulatorClient.ZRomulatorConfigId.Games);
@@ -660,31 +665,55 @@ class ZRomulatorFilesService {
         const gamesFolder = await this.gamesFolder();
         return node_path.resolve(gamesFolder, ZRomulatorFilesService.InfoFolderName);
     }
-    async repository() {
+    async contents(root, path) {
+        const repository = await this.seed();
+        const prefix = lodashEs.trimEnd(root, "/");
+        const folder = `${prefix}${node_path.sep}`;
+        let filter = new helpfulQuery.ZFilterBinaryBuilder().subject("path");
+        filter = path == null ? filter.startsWith().value(folder) : filter.equal().value(node_path.resolve(folder, path));
+        const sort = new helpfulQuery.ZSortBuilder().ascending("path").build();
+        const request = new helpfulQuery.ZDataRequestBuilder().filter(filter.build()).sort(sort).build();
+        const nodes = await repository.retrieve(request);
+        return path == null ? nodes : helpfulFn.firstDefined(null, lodashEs.first(nodes));
+    }
+    async seed() {
         const path = await this.gamesFolder();
         if (this._repository.path !== path) {
-            await this._folderWriter.write(await this.mediaFolder());
-            await this._folderWriter.write(await this.infoFolder());
+            await this._folderStream.write(await this.mediaFolder());
+            await this._folderStream.write(await this.infoFolder());
             await this._repository.initialize(path, this._globs);
         }
         return this._repository;
     }
-    async media() {
-        const repository = await this.repository();
-        const prefix = lodashEs.trimEnd(await this.mediaFolder(), "/");
-        const folder = `${prefix}${node_path.sep}`;
-        const filter = new helpfulQuery.ZFilterBinaryBuilder().subject("path").startsWith().value(folder).build();
-        const sort = new helpfulQuery.ZSortBuilder().ascending("path").build();
-        const request = new helpfulQuery.ZDataRequestBuilder().filter(filter).sort(sort).build();
-        return repository.retrieve(request);
+    async media(path) {
+        return this.contents(await this.mediaFolder(), path);
+    }
+    async systems(path) {
+        // Systems use directories.  There's a maximum limit of about 200 systems.
+        // Since we don't actually need to read any metadata or scan through thousands
+        // of unknown folders, we can use the supported system ids to just grab the
+        // systems that we need.  Since the file repository does a stat anyway, we can just
+        // grab the systems from the file system and it should be fast enough.  These are all
+        // folders, so we don't even need the stats for them and we can assume folders.
+        const games = await this.gamesFolder();
+        const folders = path == null ? this._systems.map((s)=>`${s}/`) : node_path.resolve(games, path);
+        const items = await this._fileSystem.search(folders, {
+            cwd: games
+        });
+        return path == null ? items : helpfulFn.firstDefined(null, lodashEs.first(items));
+    }
+    async info(path) {
+        return this.contents(await this.infoFolder(), path);
     }
 }
 ZRomulatorFilesService = _ts_decorate$8([
     common.Injectable(),
     _ts_param$4(0, common.Inject(ZRomulatorConfigsToken)),
+    _ts_param$4(1, common.Inject(crumbtrailNest.ZFileSystemToken)),
     _ts_metadata$4("design:type", Function),
     _ts_metadata$4("design:paramtypes", [
-        typeof IZRomulatorConfigsService === "undefined" ? Object : IZRomulatorConfigsService
+        typeof IZRomulatorConfigsService === "undefined" ? Object : IZRomulatorConfigsService,
+        typeof IZFileSystemService === "undefined" ? Object : IZFileSystemService
     ])
 ], ZRomulatorFilesService);
 
@@ -699,6 +728,7 @@ class ZRomulatorFilesModule {
 ZRomulatorFilesModule = _ts_decorate$7([
     common.Module({
         imports: [
+            crumbtrailNest.ZFileSystemModule,
             ZRomulatorConfigsModule
         ],
         providers: [
@@ -1005,13 +1035,16 @@ function _ts_param$1(paramIndex, decorator) {
 }
 const ZRomulatorSystemsToken = Symbol("romulator-systems-service");
 class ZRomulatorSystemsService {
-    _file;
-    _configs;
+    _files;
     logger;
     _logger;
-    constructor(_file, _configs, logger){
-        this._file = _file;
-        this._configs = _configs;
+    _fileStream = new crumbtrailFs.ZStreamFile({
+        cache: {
+            maxFiles: Object.keys(romulatorClient.ZRomulatorSystemId).length + 1
+        }
+    });
+    constructor(_files, logger){
+        this._files = _files;
         this.logger = logger;
         this._logger = new lumberjackyLog.ZLoggerContext("ZRomulatorSystemsService", logger);
     }
@@ -1020,18 +1053,8 @@ class ZRomulatorSystemsService {
         const size = helpfulFn.firstDefined(Infinity, req.size);
         let msg = `Retrieving systems page, ${page}, with size, ${size}.`;
         this._logger.log(new lumberjackyLog.ZLogEntryBuilder().info().message(msg).build());
-        const { contents } = await this._configs.get(romulatorClient.ZRomulatorConfigId.Games);
-        const { gamesFolder } = contents;
-        const { fallback } = romulatorClient.ZRomulatorConfigGamesMetadata.gamesFolder();
-        const _folder = helpfulFn.firstDefined(fallback, gamesFolder);
-        const cwd = helpfulFn.detokenize(_folder, process.env);
-        msg = `Looking for systems in ${cwd}`;
-        this._logger.log(new lumberjackyLog.ZLogEntryBuilder().info().message(msg).build());
-        const searchOptions = {
-            cwd
-        };
-        const folders = await this._file.search("*/", searchOptions);
-        const systems = folders.map((folder)=>folder.path).map((path)=>node_path.basename(path)).map((slug)=>this._createSystemFromSlug(slug)).filter((system)=>system != null);
+        const folders = await this._files.systems();
+        const systems = await Promise.all(folders.map((folder)=>folder.path).map((path)=>node_path.basename(path)).filter((slug)=>romulatorClient.isSystemId(slug)).map((slug)=>this._createSystemFromSlug(slug)));
         msg = `Found ${systems.length} systems`;
         this._logger.log(new lumberjackyLog.ZLogEntryBuilder().info().message(msg).build());
         const sourceOptions = new helpfulQuery.ZDataSourceStaticOptionsBuilder().search(new helpfulQuery.ZDataSearchFields([
@@ -1045,27 +1068,46 @@ class ZRomulatorSystemsService {
         return new helpfulQuery.ZPageBuilder().data(data).count(count).build();
     }
     async get(id) {
-        const all = await this.list(new helpfulQuery.ZDataRequestBuilder().build());
-        const system = lodashEs.find(all.data, (system)=>system.id === id);
-        if (!system) {
-            throw new common.NotFoundException(`Unable to find system with id, ${id}.`);
+        // The system path should be the slug itself.
+        if (!romulatorClient.isSystemId(id)) {
+            const message = `The specified system slug, ${id}, is not supported.`;
+            throw new common.NotFoundException(message);
+        }
+        const node = await this._files.systems(id);
+        if (node == null) {
+            const message = `System with slug, ${id}, was not found.`;
+            throw new common.NotFoundException(message);
         }
-        return system;
+        return this._createSystemFromSlug(id);
     }
-    _createSystemFromSlug(slug) {
-        // A romulator system's slug should read the metadata.json file from the root
-        return ZRomulatorSystemKnown.from(slug);
+    async _createSystemFromSlug(slug) {
+        const system = new romulatorClient.ZRomulatorSystemBuilder().id(slug);
+        const path = `${slug}/info.json`;
+        const info = await this._files.info(path);
+        if (info == null) {
+            // Best we can do right now.
+            return system.build();
+        }
+        try {
+            const contents = await this._fileStream.read(info.path);
+            const json = JSON.parse(contents.toString());
+            return system.assign(json).redact().build();
+        } catch (e) {
+            // Best we can do
+            const err = helpfulFn.createError(e);
+            const msg = `Cannot read system metadata, ${err.message}`;
+            this._logger.log(new lumberjackyLog.ZLogEntryBuilder().error().message(msg).build());
+            return system.build();
+        }
     }
 }
 ZRomulatorSystemsService = _ts_decorate$3([
     common.Injectable(),
-    _ts_param$1(0, common.Inject(crumbtrailNest.ZFileSystemToken)),
-    _ts_param$1(1, common.Inject(ZRomulatorConfigsToken)),
-    _ts_param$1(2, common.Inject(lumberjackyNest.ZLoggerToken)),
+    _ts_param$1(0, common.Inject(ZRomulatorFilesToken)),
+    _ts_param$1(1, common.Inject(lumberjackyNest.ZLoggerToken)),
     _ts_metadata$1("design:type", Function),
     _ts_metadata$1("design:paramtypes", [
-        typeof IZFileSystemService === "undefined" ? Object : IZFileSystemService,
-        typeof IZRomulatorConfigsService === "undefined" ? Object : IZRomulatorConfigsService,
+        typeof IZRomulatorFilesService === "undefined" ? Object : IZRomulatorFilesService,
         typeof IZLogger === "undefined" ? Object : IZLogger
     ])
 ], ZRomulatorSystemsService);
@@ -1139,8 +1181,7 @@ class ZRomulatorSystemsModule {
 ZRomulatorSystemsModule = _ts_decorate$1([
     common.Module({
         imports: [
-            ZRomulatorConfigsModule,
-            crumbtrailNest.ZFileSystemModule,
+            ZRomulatorFilesModule,
             lumberjackyNest.ZLoggerModule
         ],
         controllers: [