@open-audio-stack/core 0.0.18 → 0.0.21

package/build/helpers/file.d.ts

@@ -1,7 +1,8 @@
-import { PackageInterface, PackageValidationError } from '../types/Package.js';
+import { PackageInterface } from '../types/Package.js';
 import { PluginFile } from '../types/Plugin.js';
 import { PresetFile } from '../types/Preset.js';
 import { ProjectFile } from '../types/Project.js';
+import { ZodIssue } from 'zod';
 export declare function dirApp(): string;
 export declare function dirCreate(dir: string): string | false;
 export declare function dirDelete(dir: string): false | void;
@@ -30,6 +31,6 @@ export declare function fileReadJson(filePath: string): any;
 export declare function fileReadString(filePath: string): string;
 export declare function fileReadYaml(filePath: string): unknown;
 export declare function fileSize(filePath: string): number;
-export declare function fileValidateMetadata(filePath: string, fileMetadata: PluginFile | PresetFile | ProjectFile): Promise<PackageValidationError[]>;
+export declare function fileValidateMetadata(filePath: string, fileMetadata: PluginFile | PresetFile | ProjectFile): Promise<ZodIssue[]>;
 export declare function zipCreate(filesPath: string, zipPath: string): void;
 export declare function zipExtract(content: any, dirPath: string): void;

package/build/helpers/file.js

@@ -8,7 +8,7 @@ import { moveSync } from 'fs-extra/esm';
 import os from 'os';
 import path from 'path';
 import yaml from 'js-yaml';
-import { PackageValidation } from '../types/Package.js';
+import { ZodIssueCode } from 'zod';
 export function dirApp() {
     if (process.platform === 'win32')
         return process.env.APPDATA || os.homedir();
@@ -183,18 +183,20 @@ export async function fileValidateMetadata(filePath, fileMetadata) {
     const hash = await fileHash(filePath);
     if (fileMetadata.sha256 !== hash) {
         errors.push({
-            field: 'sha256',
-            error: PackageValidation.INVALID_VALUE,
-            valueExpected: hash,
-            valueReceived: fileMetadata.sha256,
+            code: ZodIssueCode.invalid_type,
+            expected: hash,
+            message: 'Required',
+            path: ['sha256'],
+            received: fileMetadata.sha256,
         });
     }
     if (fileMetadata.size !== fileSize(filePath)) {
         errors.push({
-            field: 'size',
-            error: PackageValidation.INVALID_VALUE,
-            valueExpected: String(fileSize(filePath)),
-            valueReceived: String(fileMetadata.size),
+            code: ZodIssueCode.invalid_type,
+            expected: String(fileSize(filePath)),
+            message: 'Required',
+            path: ['size'],
+            received: String(fileMetadata.size),
         });
     }
     return errors;

package/build/helpers/package.d.ts

@@ -1,5 +1,222 @@
-import { PluginFile, PresetFile, ProjectFile } from '../index-browser.js';
-import { PackageValidationError, PackageValidationRec, PackageVersionType } from '../types/Package.js';
+import { z } from 'zod';
+import { Architecture } from '../types/Architecture.js';
+import { FileFormat } from '../types/FileFormat.js';
+import { FileType } from '../types/FileType.js';
+import { License } from '../types/License.js';
+import { PluginFile } from '../types/Plugin.js';
+import { PluginType } from '../types/PluginType.js';
+import { PresetFile } from '../types/Preset.js';
+import { PresetType } from '../types/PresetType.js';
+import { ProjectFile } from '../types/Project.js';
+import { ProjectType } from '../types/ProjectType.js';
+import { SystemType } from '../types/SystemType.js';
+import { PackageValidationRec, PackageVersionType } from '../types/Package.js';
+export declare const PackageSystemValidator: z.ZodObject<{
+    max: z.ZodOptional<z.ZodNumber>;
+    min: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodNativeEnum<typeof SystemType>;
+}, "strip", z.ZodTypeAny, {
+    type: SystemType;
+    max?: number | undefined;
+    min?: number | undefined;
+}, {
+    type: SystemType;
+    max?: number | undefined;
+    min?: number | undefined;
+}>;
+export declare const PackageFileValidator: z.ZodObject<{
+    architectures: z.ZodArray<z.ZodNativeEnum<typeof Architecture>, "many">;
+    format: z.ZodNativeEnum<typeof FileFormat>;
+    sha256: z.ZodString;
+    size: z.ZodNumber;
+    systems: z.ZodArray<z.ZodObject<{
+        max: z.ZodOptional<z.ZodNumber>;
+        min: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodNativeEnum<typeof SystemType>;
+    }, "strip", z.ZodTypeAny, {
+        type: SystemType;
+        max?: number | undefined;
+        min?: number | undefined;
+    }, {
+        type: SystemType;
+        max?: number | undefined;
+        min?: number | undefined;
+    }>, "many">;
+    type: z.ZodNativeEnum<typeof FileType>;
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    type: FileType;
+    architectures: Architecture[];
+    format: FileFormat;
+    sha256: string;
+    size: number;
+    systems: {
+        type: SystemType;
+        max?: number | undefined;
+        min?: number | undefined;
+    }[];
+}, {
+    url: string;
+    type: FileType;
+    architectures: Architecture[];
+    format: FileFormat;
+    sha256: string;
+    size: number;
+    systems: {
+        type: SystemType;
+        max?: number | undefined;
+        min?: number | undefined;
+    }[];
+}>;
+export declare const PackageTypeObj: {
+    Audiobook: ProjectType.Audiobook;
+    DJSet: ProjectType.DJSet;
+    Performance: ProjectType.Performance;
+    Podcast: ProjectType.Podcast;
+    Remix: ProjectType.Remix;
+    Song: ProjectType.Song;
+    Score: ProjectType.Score;
+    Chain: PresetType.Chain;
+    Layout: PresetType.Layout;
+    Mapping: PresetType.Mapping;
+    Patch: PresetType.Patch;
+    Pattern: PresetType.Pattern;
+    Theme: PresetType.Theme;
+    Effect: PluginType.Effect;
+    Generator: PluginType.Generator;
+    Instrument: PluginType.Instrument;
+    Preset: PluginType.Preset;
+    Sampler: PluginType.Sampler;
+    Tool: PluginType.Tool;
+};
+export declare const PackageVersionValidator: z.ZodObject<{
+    audio: z.ZodString;
+    author: z.ZodString;
+    changes: z.ZodString;
+    date: z.ZodString;
+    description: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        architectures: z.ZodArray<z.ZodNativeEnum<typeof Architecture>, "many">;
+        format: z.ZodNativeEnum<typeof FileFormat>;
+        sha256: z.ZodString;
+        size: z.ZodNumber;
+        systems: z.ZodArray<z.ZodObject<{
+            max: z.ZodOptional<z.ZodNumber>;
+            min: z.ZodOptional<z.ZodNumber>;
+            type: z.ZodNativeEnum<typeof SystemType>;
+        }, "strip", z.ZodTypeAny, {
+            type: SystemType;
+            max?: number | undefined;
+            min?: number | undefined;
+        }, {
+            type: SystemType;
+            max?: number | undefined;
+            min?: number | undefined;
+        }>, "many">;
+        type: z.ZodNativeEnum<typeof FileType>;
+        url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        type: FileType;
+        architectures: Architecture[];
+        format: FileFormat;
+        sha256: string;
+        size: number;
+        systems: {
+            type: SystemType;
+            max?: number | undefined;
+            min?: number | undefined;
+        }[];
+    }, {
+        url: string;
+        type: FileType;
+        architectures: Architecture[];
+        format: FileFormat;
+        sha256: string;
+        size: number;
+        systems: {
+            type: SystemType;
+            max?: number | undefined;
+            min?: number | undefined;
+        }[];
+    }>, "many">;
+    image: z.ZodString;
+    license: z.ZodNativeEnum<typeof License>;
+    name: z.ZodString;
+    tags: z.ZodArray<z.ZodString, "many">;
+    type: z.ZodNativeEnum<{
+        Audiobook: ProjectType.Audiobook;
+        DJSet: ProjectType.DJSet;
+        Performance: ProjectType.Performance;
+        Podcast: ProjectType.Podcast;
+        Remix: ProjectType.Remix;
+        Song: ProjectType.Song;
+        Score: ProjectType.Score;
+        Chain: PresetType.Chain;
+        Layout: PresetType.Layout;
+        Mapping: PresetType.Mapping;
+        Patch: PresetType.Patch;
+        Pattern: PresetType.Pattern;
+        Theme: PresetType.Theme;
+        Effect: PluginType.Effect;
+        Generator: PluginType.Generator;
+        Instrument: PluginType.Instrument;
+        Preset: PluginType.Preset;
+        Sampler: PluginType.Sampler;
+        Tool: PluginType.Tool;
+    }>;
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    audio: string;
+    author: string;
+    changes: string;
+    date: string;
+    description: string;
+    image: string;
+    license: License;
+    name: string;
+    tags: string[];
+    url: string;
+    type: PluginType | PresetType | ProjectType;
+    files: {
+        url: string;
+        type: FileType;
+        architectures: Architecture[];
+        format: FileFormat;
+        sha256: string;
+        size: number;
+        systems: {
+            type: SystemType;
+            max?: number | undefined;
+            min?: number | undefined;
+        }[];
+    }[];
+}, {
+    audio: string;
+    author: string;
+    changes: string;
+    date: string;
+    description: string;
+    image: string;
+    license: License;
+    name: string;
+    tags: string[];
+    url: string;
+    type: PluginType | PresetType | ProjectType;
+    files: {
+        url: string;
+        type: FileType;
+        architectures: Architecture[];
+        format: FileFormat;
+        sha256: string;
+        size: number;
+        systems: {
+            type: SystemType;
+            max?: number | undefined;
+            min?: number | undefined;
+        }[];
+    }[];
+}>;
 export declare function packageRecommendations(pkgVersion: PackageVersionType): PackageValidationRec[];
 export declare function packageRecommendationsUrl(obj: PackageVersionType | PluginFile | PresetFile | ProjectFile, recs: PackageValidationRec[], field: string): void;
-export declare function packageValidate(pkgVersion: PackageVersionType): PackageValidationError[];

package/build/helpers/package.js

@@ -1,5 +1,44 @@
+import { z } from 'zod';
+import { Architecture } from '../types/Architecture.js';
+import { FileFormat } from '../types/FileFormat.js';
+import { FileType } from '../types/FileType.js';
 import { License } from '../types/License.js';
-import { PackageValidation, } from '../types/Package.js';
+import { PluginType } from '../types/PluginType.js';
+import { PresetType } from '../types/PresetType.js';
+import { ProjectType } from '../types/ProjectType.js';
+import { SystemType } from '../types/SystemType.js';
+// This is a first version using zod library for validation.
+// If it works well, consider updating all types to infer from Zod objects.
+// This will remove duplicatation of code between types and validators.
+export const PackageSystemValidator = z.object({
+    max: z.number().min(0).max(99).optional(),
+    min: z.number().min(0).max(99).optional(),
+    type: z.nativeEnum(SystemType),
+});
+export const PackageFileValidator = z.object({
+    architectures: z.nativeEnum(Architecture).array(),
+    format: z.nativeEnum(FileFormat),
+    sha256: z.string().length(64),
+    size: z.number().min(0).max(9999999999),
+    systems: PackageSystemValidator.array(),
+    type: z.nativeEnum(FileType),
+    url: z.string().min(0).max(256).startsWith('https://'),
+});
+export const PackageTypeObj = { ...PluginType, ...PresetType, ...ProjectType };
+export const PackageVersionValidator = z.object({
+    audio: z.string().min(0).max(256).startsWith('https://'),
+    author: z.string().min(0).max(256),
+    changes: z.string().min(0).max(256),
+    date: z.string().datetime(),
+    description: z.string().min(0).max(256),
+    files: z.array(PackageFileValidator),
+    image: z.string().min(0).max(256).startsWith('https://'),
+    license: z.nativeEnum(License),
+    name: z.string().min(0).max(256),
+    tags: z.string().min(0).max(256).array(),
+    type: z.nativeEnum(PackageTypeObj),
+    url: z.string().min(0).max(256).startsWith('https://'),
+});
 // TODO refactor all this using a proper validation library.
 export function packageRecommendations(pkgVersion) {
     const recs = [];
@@ -72,40 +111,3 @@ export function packageRecommendationsUrl(obj, recs, field) {
         });
     }
 }
-export function packageValidate(pkgVersion) {
-    const fields = [
-        { name: 'audio', type: 'string' },
-        { name: 'author', type: 'string' },
-        { name: 'changes', type: 'string' },
-        { name: 'date', type: 'string' },
-        { name: 'description', type: 'string' },
-        { name: 'files', type: 'object' },
-        { name: 'image', type: 'string' },
-        { name: 'license', type: 'string' },
-        { name: 'name', type: 'string' },
-        { name: 'tags', type: 'object' },
-        { name: 'type', type: 'string' },
-        { name: 'url', type: 'string' },
-    ];
-    const errors = [];
-    fields.forEach((field) => {
-        const versionField = pkgVersion[field.name];
-        if (versionField === undefined) {
-            errors.push({
-                field: field.name,
-                error: PackageValidation.MISSING_FIELD,
-                valueExpected: field.type,
-                valueReceived: 'undefined',
-            });
-        }
-        else if (typeof versionField !== field.type) {
-            errors.push({
-                field: field.name,
-                error: PackageValidation.INVALID_TYPE,
-                valueExpected: field.type,
-                valueReceived: typeof versionField,
-            });
-        }
-    });
-    return errors;
-}

package/build/helpers/utils.d.ts

@@ -1,6 +1,7 @@
-import { PackageValidationError, PackageValidationRec } from '../types/Package.js';
-export declare function logReport(info: string, errors?: PackageValidationError[], recs?: PackageValidationRec[]): void;
-export declare function logErrors(errors: PackageValidationError[]): void;
+import { PackageValidationRec } from '../types/Package.js';
+import { ZodIssue } from 'zod';
+export declare function logReport(info: string, errors?: ZodIssue[], recs?: PackageValidationRec[]): void;
+export declare function logErrors(errors: ZodIssue[]): void;
 export declare function logRecommendations(recs: PackageValidationRec[]): void;
 export declare function pathGetExt(path: string, sep?: string): string;
 export declare function pathGetDirectory(path: string, sep?: string): string;

package/build/helpers/utils.js

@@ -12,7 +12,15 @@ export function logReport(info, errors, recs) {
 }
 export function logErrors(errors) {
     errors.forEach(error => {
-        console.log(chalk.red(`- ${error.field} (${error.error}) received '${error.valueReceived}' expected '${error.valueExpected}'`));
+        // @ts-expect-error need to filter by code.
+        if (error.received) {
+            console.log(chalk.red(
+            // @ts-expect-error need to filter by code.
+            `- ${error.path} (${error.message}) received '${error.received}' expected '${error.expected}'`));
+        }
+        else {
+            console.log(chalk.red(`- ${error.path} (${error.message})`));
+        }
     });
 }
 export function logRecommendations(recs) {

package/build/types/Package.d.ts

@@ -32,12 +32,6 @@ export interface PackageValidationField {
     name: string;
     type: string;
 }
-export interface PackageValidationError {
-    field: string;
-    error: PackageValidation;
-    valueExpected: boolean | number | string;
-    valueReceived: boolean | number | string;
-}
 export interface PackageValidationRec {
     field: string;
     rec: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-audio-stack/core",
-  "version": "0.0.18",
+  "version": "0.0.21",
   "description": "Open-source audio plugin management software",
   "type": "module",
   "main": "./build/index.js",
@@ -56,7 +56,8 @@
     "fs-extra": "^11.2.0",
     "glob": "^11.0.0",
     "js-yaml": "^4.1.0",
-    "semver": "^7.6.3"
+    "semver": "^7.6.3",
+    "zod": "^3.23.8"
   },
   "repository": {
     "type": "git",