@open-audio-stack/core 0.1.8 → 0.1.10

package/build/classes/ConfigLocal.d.ts

@@ -4,6 +4,8 @@ export declare class ConfigLocal extends Config {
     path: string;
     constructor(configPath: string, config?: ConfigInterface);
     delete(): boolean | void;
+    export(dir: string, ext?: string): boolean;
+    exportConfig(dirRoot: string, items: any, ext?: string): void;
     load(): ConfigInterface;
     save(): void;
     set(key: keyof ConfigInterface, val: any): void;

package/build/classes/ConfigLocal.js

@@ -1,6 +1,6 @@
 import path from 'path';
 import { Config } from './Config.js';
-import { dirCreate, fileCreateJson, fileDelete, fileExists, fileReadJson } from '../helpers/file.js';
+import { dirCreate, fileCreateJson, fileCreateYaml, fileDelete, fileExists, fileReadJson } from '../helpers/file.js';
 import { configDefaultsLocal } from '../helpers/configLocal.js';
 export class ConfigLocal extends Config {
     path;
@@ -18,6 +18,29 @@ export class ConfigLocal extends Config {
     delete() {
         return fileDelete(this.path);
     }
+    export(dir, ext = 'json') {
+        // TODO improve the way this is handled.
+        this.exportConfig(path.join(dir, 'architectures'), this.architectures(), ext);
+        this.exportConfig(path.join(dir, 'file-formats'), this.fileFormats(), ext);
+        this.exportConfig(path.join(dir, 'file-types'), this.fileTypes(), ext);
+        this.exportConfig(path.join(dir, 'licenses'), this.licenses(), ext);
+        this.exportConfig(path.join(dir, 'plugin-formats'), this.pluginFormats(), ext);
+        this.exportConfig(path.join(dir, 'plugin-types'), this.pluginTypes(), ext);
+        this.exportConfig(path.join(dir, 'preset-formats'), this.presetFormats(), ext);
+        this.exportConfig(path.join(dir, 'preset-types'), this.presetTypes(), ext);
+        this.exportConfig(path.join(dir, 'project-formats'), this.projectFormats(), ext);
+        this.exportConfig(path.join(dir, 'project-types'), this.projectTypes(), ext);
+        this.exportConfig(path.join(dir, 'systems'), this.systems(), ext);
+        return true;
+    }
+    exportConfig(dirRoot, items, ext = 'json') {
+        const saveFile = ext === 'yaml' ? fileCreateYaml : fileCreateJson;
+        items.forEach((item) => {
+            dirCreate(path.join(dirRoot, item.value));
+            saveFile(path.join(dirRoot, item.value, `index.${ext}`), item);
+        });
+        saveFile(path.join(dirRoot, `index.${ext}`), items);
+    }
     load() {
         return fileReadJson(this.path);
     }

package/build/classes/Manager.d.ts

@@ -11,6 +11,7 @@ export declare class Manager {
     addPackage(pkg: Package): void;
     filter(method: (pkgVersion: PackageVersion, pkg: Package) => boolean): Package[];
     getPackage(slug: string): Package | undefined;
+    getReport(): any;
     listPackages(): Package[];
     removePackage(slug: string): void;
     reset(): void;

package/build/classes/Manager.js

@@ -11,14 +11,13 @@ export class Manager {
         this.type = type;
     }
     addPackage(pkg) {
-        const pkgExisting = this.packages.get(pkg.slug);
-        if (pkgExisting) {
-            for (const [version, pkgVersion] of pkg.versions) {
-                pkgExisting.addVersion(version, pkgVersion);
-            }
+        let pkgExisting = this.packages.get(pkg.slug);
+        if (!pkgExisting) {
+            pkgExisting = new Package(pkg.slug);
+            this.packages.set(pkg.slug, pkgExisting);
         }
-        else {
-            this.packages.set(pkg.slug, pkg);
+        for (const [version, pkgVersion] of pkg.versions) {
+            pkgExisting.addVersion(version, pkgVersion);
         }
     }
     filter(method) {
@@ -34,6 +33,15 @@ export class Manager {
     getPackage(slug) {
         return this.packages.get(slug);
     }
+    getReport() {
+        const reports = {};
+        for (const [slug, pkg] of this.packages) {
+            const report = pkg.getReport();
+            if (Object.keys(report).length)
+                reports[slug] = report;
+        }
+        return reports;
+    }
     listPackages() {
         return Array.from(this.packages.values());
     }

package/build/classes/ManagerLocal.d.ts

@@ -5,7 +5,8 @@ import { ConfigInterface } from '../types/Config.js';
 export declare class ManagerLocal extends Manager {
     protected typeDir: string;
     constructor(type: RegistryType, config: ConfigInterface);
-    scan(ext?: string): void;
+    scan(ext?: string, installable?: boolean): void;
+    export(dir: string, ext?: string): boolean;
     install(slug: string, version?: string): Promise<void | PackageVersion>;
     uninstall(slug: string, version?: string): Promise<void | PackageVersion>;
 }

package/build/classes/ManagerLocal.js

@@ -1,7 +1,7 @@
 import path from 'path';
 import { Package } from './Package.js';
 import { Manager } from './Manager.js';
-import { archiveExtract, dirCreate, dirDelete, dirEmpty, dirRead, fileCreate, fileCreateJson, fileExists, fileHash, fileOpen, fileReadJson, fileReadYaml, filesMove, isAdmin, runCliAsAdmin, } from '../helpers/file.js';
+import { archiveExtract, dirCreate, dirDelete, dirEmpty, dirRead, fileCreate, fileCreateJson, fileCreateYaml, fileExists, fileHash, fileOpen, fileReadJson, fileReadYaml, filesMove, isAdmin, runCliAsAdmin, } from '../helpers/file.js';
 import { pathGetSlug, pathGetVersion } from '../helpers/utils.js';
 import { commandExists, getArchitecture, getSystem, isTests } from '../helpers/utilsLocal.js';
 import { apiBuffer } from '../helpers/api.js';
@@ -21,17 +21,44 @@ export class ManagerLocal extends Manager {
         this.config = new ConfigLocal(configPath, config);
         this.typeDir = this.config.get(`${type}Dir`);
     }
-    scan(ext = 'json') {
+    scan(ext = 'json', installable = true) {
         const filePaths = dirRead(`${this.typeDir}/**/index.${ext}`);
         filePaths.forEach((filePath) => {
             const subPath = filePath.replace(`${this.typeDir}/`, '');
             const pkgJson = ext === 'yaml' ? fileReadYaml(filePath) : fileReadJson(filePath);
-            pkgJson.installed = true;
+            if (installable)
+                pkgJson.installed = true;
             const pkg = new Package(pathGetSlug(subPath));
-            pkg.addVersion(pathGetVersion(subPath), pkgJson);
+            const version = pathGetVersion(subPath);
+            pkg.addVersion(version, pkgJson);
             this.addPackage(pkg);
         });
     }
+    export(dir, ext = 'json') {
+        const packagesByOrg = {};
+        const filename = `index.${ext}`;
+        const saveFile = ext === 'yaml' ? fileCreateYaml : fileCreateJson;
+        for (const [pkgSlug, pkg] of this.packages) {
+            for (const [version, pkgVersion] of pkg.versions) {
+                dirCreate(path.join(dir, pkgSlug, version));
+                saveFile(path.join(dir, pkgSlug, version, filename), pkgVersion);
+            }
+            saveFile(path.join(dir, pkgSlug, filename), pkg.toJSON());
+            // TODO find a more elegant way to handle org exports.
+            const pkgOrg = pkgSlug.split('/')[0];
+            if (!packagesByOrg[pkgOrg])
+                packagesByOrg[pkgOrg] = {};
+            packagesByOrg[pkgOrg][pkgSlug] = pkg.toJSON();
+        }
+        for (const orgId in packagesByOrg) {
+            dirCreate(path.join(dir, orgId));
+            saveFile(path.join(dir, orgId, filename), packagesByOrg[orgId]);
+        }
+        dirCreate(dir);
+        saveFile(path.join(dir, filename), this.toJSON());
+        saveFile(path.join(dir, `report.${ext}`), this.getReport());
+        return true;
+    }
     async install(slug, version) {
         // Get package information from registry.
         const pkg = this.getPackage(slug);

package/build/classes/Package.d.ts

@@ -1,13 +1,23 @@
-import { PackageInterface, PackageVersion, PackageVersions } from '../types/Package.js';
+import { PackageReport, PackageVersion, PackageVersions } from '../types/Package.js';
 export declare class Package {
+    reports: Map<string, PackageReport>;
     slug: string;
     version: string;
     versions: Map<string, PackageVersion>;
     constructor(slug: string, versions?: PackageVersions);
     addVersion(version: string, details: PackageVersion): void;
     removeVersion(version: string): void;
+    getReport(): {
+        [k: string]: PackageReport;
+    };
     getVersion(version: string): PackageVersion | undefined;
     getVersionLatest(): PackageVersion | undefined;
     latestVersion(): string;
-    toJSON(): PackageInterface;
+    toJSON(): {
+        slug: string;
+        version: string;
+        versions: {
+            [k: string]: PackageVersion;
+        };
+    };
 }

package/build/classes/Package.js

@@ -1,13 +1,15 @@
 import * as semver from 'semver';
-import { PackageVersionValidator } from '../helpers/package.js';
+import { packageErrors, packageRecommendations } from '../helpers/package.js';
 import { isValidSlug } from '../helpers/utils.js';
 export class Package {
+    reports;
     slug;
     version;
     versions;
     constructor(slug, versions) {
         if (!isValidSlug(slug))
             console.error('Invalid package slug', slug);
+        this.reports = new Map();
         this.slug = slug;
         this.versions = versions ? new Map(Object.entries(versions)) : new Map();
         this.version = this.latestVersion();
@@ -15,9 +17,16 @@ export class Package {
     addVersion(version, details) {
         if (this.versions.has(version))
             return;
-        const validationError = PackageVersionValidator.safeParse(details).error;
-        if (validationError)
-            return console.error('Invalid package version', validationError.issues);
+        const errors = packageErrors(details);
+        const recs = packageRecommendations(details);
+        const report = {
+            ...(errors.length > 0 && { errors }),
+            ...(recs.length > 0 && { recs }),
+        };
+        if (Object.keys(report).length > 0)
+            this.reports.set(version, report);
+        if (errors.length > 0)
+            return;
         this.versions.set(version, details);
         this.version = this.latestVersion();
     }
@@ -27,6 +36,9 @@ export class Package {
         this.versions.delete(version);
         this.version = this.latestVersion();
     }
+    getReport() {
+        return Object.fromEntries(this.reports);
+    }
     getVersion(version) {
         return this.versions.get(version);
     }
@@ -37,14 +49,10 @@ export class Package {
         return Array.from(this.versions.keys()).sort(semver.rcompare)[0] || '0.0.0';
     }
     toJSON() {
-        const data = {
+        return {
             slug: this.slug,
             version: this.version,
-            versions: {},
+            versions: Object.fromEntries(this.versions),
         };
-        this.versions.forEach((details, version) => {
-            data.versions[version] = details;
-        });
-        return data;
     }
 }

package/build/classes/RegistryLocal.d.ts

@@ -3,5 +3,6 @@ import { Registry } from './Registry.js';
 export declare class RegistryLocal extends Registry {
     protected managers: Record<string, ManagerLocal>;
     constructor(name: string, url: string, version: string);
-    scan(ext?: string): void;
+    export(dir: string, ext?: string): boolean;
+    scan(ext?: string, installable?: boolean): void;
 }

package/build/classes/RegistryLocal.js

@@ -1,13 +1,24 @@
+import path from 'path';
 import { Registry } from './Registry.js';
+import { dirCreate, fileCreateJson, fileCreateYaml } from '../helpers/file.js';
 export class RegistryLocal extends Registry {
     managers;
     constructor(name, url, version) {
         super(name, url, version);
         this.managers = {};
     }
-    scan(ext = 'json') {
+    export(dir, ext = 'json') {
+        const saveFile = ext === 'yaml' ? fileCreateYaml : fileCreateJson;
         for (const [, manager] of Object.entries(this.managers)) {
-            manager.scan(ext);
+            manager.export(path.join(dir, manager.type), ext);
+        }
+        dirCreate(dir);
+        saveFile(path.join(dir, `index.${ext}`), this.toJSON());
+        return true;
+    }
+    scan(ext = 'json', installable = true) {
+        for (const [, manager] of Object.entries(this.managers)) {
+            manager.scan(ext, installable);
         }
     }
 }

package/build/helpers/admin.js

@@ -14,7 +14,7 @@ export function adminArguments() {
 export async function adminInit() {
     const argv = adminArguments();
     const manager = new ManagerLocal(argv.type, { appDir: dirApp() });
-    manager.sync();
+    await manager.sync();
     if (argv.operation === 'install') {
         await manager.install(argv.id, argv.ver);
     }

package/build/helpers/file.d.ts

@@ -22,6 +22,7 @@ export declare function dirRead(dir: string, options?: any): string[];
 export declare function dirRename(dir: string, dirNew: string): void | boolean;
 export declare function fileCreate(filePath: string, data: string | Buffer): void;
 export declare function fileCreateJson(filePath: string, data: object): void;
+export declare function fileCreateYaml(filePath: string, data: object): void;
 export declare function fileDate(filePath: string): Date;
 export declare function fileDelete(filePath: string): boolean | void;
 export declare function fileExec(filePath: string): void;

package/build/helpers/file.js

@@ -142,6 +142,9 @@ export function fileCreate(filePath, data) {
 export function fileCreateJson(filePath, data) {
     return fileCreate(filePath, JSON.stringify(data, null, 2));
 }
+export function fileCreateYaml(filePath, data) {
+    return fileCreate(filePath, yaml.dump(data));
+}
 export function fileDate(filePath) {
     return statSync(filePath).mtime;
 }

package/build/helpers/package.d.ts

@@ -12,6 +12,7 @@ import { ProjectType } from '../types/ProjectType.js';
 import { SystemType } from '../types/SystemType.js';
 import { PackageFileMap, PackageInterface, PackageValidationRec, PackageVersion } from '../types/Package.js';
 export declare function packageCompatibleFiles(pkg: PackageVersion, arch: Architecture[], sys: SystemType[], excludedFormats?: FileFormat[]): (PluginFile | PresetFile | ProjectFile)[];
+export declare function packageErrors(pkgVersion: PackageVersion): z.ZodIssue[];
 export declare function packageFileMap(pkgVersion: PackageVersion): PackageFileMap;
 export declare function packageVersionLatest(pkg: PackageInterface): string;
 export declare const PackageSystemValidator: z.ZodObject<{
@@ -171,12 +172,10 @@ export declare const PackageVersionValidator: z.ZodObject<{
     }>;
     url: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    type: PluginType | PresetType | ProjectType;
-    date: string;
-    url: string;
     audio: string;
     author: string;
     changes: string;
+    date: string;
     description: string;
     files: {
         type: FileType;
@@ -191,17 +190,17 @@ export declare const PackageVersionValidator: z.ZodObject<{
         }[];
         url: string;
     }[];
+    type: PluginType | PresetType | ProjectType;
+    url: string;
     image: string;
     license: License;
     name: string;
     tags: string[];
 }, {
-    type: PluginType | PresetType | ProjectType;
-    date: string;
-    url: string;
     audio: string;
     author: string;
     changes: string;
+    date: string;
     description: string;
     files: {
         type: FileType;
@@ -216,6 +215,8 @@ export declare const PackageVersionValidator: z.ZodObject<{
         }[];
         url: string;
     }[];
+    type: PluginType | PresetType | ProjectType;
+    url: string;
     image: string;
     license: License;
     name: string;

package/build/helpers/package.js

@@ -20,6 +20,9 @@ export function packageCompatibleFiles(pkg, arch, sys, excludedFormats) {
         return archMatches.length && sysMatches.length && formatAllowed;
     });
 }
+export function packageErrors(pkgVersion) {
+    return PackageVersionValidator.safeParse(pkgVersion).error?.issues || [];
+}
 export function packageFileMap(pkgVersion) {
     return pkgVersion.files.reduce((result, file) => {
         file.systems.forEach(system => {

package/build/types/Package.d.ts

@@ -2,6 +2,7 @@ import { PluginFile, PluginFileMap, PluginInterface } from './Plugin.js';
 import { PresetFile, PresetFileMap, PresetInterface } from './Preset.js';
 import { ProjectFile, ProjectFileMap, ProjectInterface } from './Project.js';
 import { License } from './License.js';
+import { ZodIssue } from 'zod';
 export interface PackageInterface {
     slug: string;
     version: string;
@@ -23,6 +24,10 @@ export interface PackageBase {
     tags: string[];
     url: string;
 }
+export interface PackageReport {
+    errors?: ZodIssue[];
+    recs?: PackageValidationRec[];
+}
 export type PackageVersion = PluginInterface | PresetInterface | ProjectInterface;
 export type PackageFile = PluginFile | PresetFile | ProjectFile;
 export type PackageFileMap = PluginFileMap | PresetFileMap | ProjectFileMap;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-audio-stack/core",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Open-source audio plugin management software",
   "type": "module",
   "main": "./build/index.js",
@@ -14,6 +14,7 @@
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "check": "npm run format && npm run lint && npm run build",
     "dev": "tsx ./src/index.ts",
     "format": "prettier . --write",
     "lint": "eslint .",