feat: enhance registry management with schema validation and improved error handling

Author: JakubAndrysek

packages/project/package.json

@@ -23,6 +23,10 @@
         "./fs": {
             "types": "./dist/src/fs/index.d.ts",
             "import": "./dist/src/fs/index.js"
+        },
+        "./registry": {
+            "types": "./dist/src/project/registry.d.ts",
+            "import": "./dist/src/project/registry.js"
         }
     },
     "files": [

packages/project/src/project/index.ts

@@ -10,7 +10,6 @@ import {
     RegistryUris,
     Dependencies,
     Dependency,
-    JacLyFiles,
     PackageJson,
     splitLibraryNameVersion,
     getPackagePath,
@@ -310,17 +309,30 @@ export class Project {
         const resolvedDeps = await this.resolveDependencies(pkg.dependencies);
         const jaclyFiles: string[] = [];
         for (const [libName] of Object.entries(resolvedDeps)) {
-            const pkg = await loadPackageJson(this.fs, path.join(libName, "package.json"));
+            const pkg = await loadPackageJson(this.fs, path.join(this.projectPath, "node_modules", libName, "package.json"));
             if (!pkg) {
                 this.err.write(
                     `Failed to load package.json for '${libName}'. Install dependencies before fetching JacLy files.\n`
                 );
                 continue;
             }
             if (pkg.jaculus && pkg.jaculus.blocks) {
-                jaclyFiles.push(
-                    path.join(getPackagePath(this.projectPath, libName), pkg.jaculus.blocks)
-                );
+                const blockFilePath = path.join(this.projectPath, "node_modules", libName, pkg.jaculus.blocks);
+                // read folder and add all .json file
+                if (this.fs.existsSync(blockFilePath)) {
+                    const files = this.fs.readdirSync(blockFilePath);
+                    for (const file of files) {
+                        const justFilename = path.basename(file);
+                        if (file.endsWith(".json") && !justFilename.startsWith(".")) {
+                            const fullPath = path.join(blockFilePath, file);
+                            jaclyFiles.push(fullPath);
+                        }
+                    }
+                } else {
+                    this.err.write(
+                        `JacLy blocks folder '${blockFilePath}' does not exist for library '${libName}'.\n`
+                    );
+                }
             }
         }
         return jaclyFiles;
@@ -331,7 +343,6 @@ export {
     Registry,
     Dependency,
     Dependencies,
-    JacLyFiles,
     RegistryUris,
     PackageJson,
     parsePackageJson,

packages/project/src/project/package.ts

@@ -25,20 +25,17 @@ const DescriptionSchema = z.string();
 // - in first version, only exact versions are supported
 const DependenciesSchema = z.record(NameSchema, VersionSchema);
 
-const JacLyFilesSchema = z.array(z.string());
-
 const RegistryUrisSchema = z.array(z.string());
 
 const JaculusSchema = z.object({
     blocks: z.string().optional(),
 });
 
 const PackageJsonSchema = z.object({
-    name: NameSchema.optional(),
-    version: VersionSchema.optional(),
+    name: NameSchema,
+    version: VersionSchema,
     description: DescriptionSchema.optional(),
     dependencies: DependenciesSchema.default({}),
-    jacly: JacLyFilesSchema.optional(),
     registry: RegistryUrisSchema.optional(),
     jaculus: JaculusSchema.optional(),
 });
@@ -48,7 +45,6 @@ export type Dependency = {
     version: string;
 };
 export type Dependencies = z.infer<typeof DependenciesSchema>;
-export type JacLyFiles = z.infer<typeof JacLyFilesSchema>;
 export type RegistryUris = z.infer<typeof RegistryUrisSchema>;
 export type PackageJson = z.infer<typeof PackageJsonSchema>;
 

packages/project/src/project/registry.ts

@@ -1,9 +1,66 @@
 import semver from "semver";
 import { getRequestJson, RequestFunction } from "../fs/index.js";
 import { PackageJson, parsePackageJson } from "./package.js";
+import * as z from "zod";
 
 export const DefaultRegistryUrl = ["https://f.jaculus.org/libs"];
 
+
+/**
+ *
+ * Registry dist structure:
+ *  outputRegistryDist/
+ *   |-- packageName/
+ *   |    |-- version/
+ *   |    |   |-- package.tar.gz
+ *   |    |   |-- package.json (same as in package)
+ *	 |-- versions.json (list of versions) [{"version":"0.0.24"},{"version":"0.0.25"}]
+* 	 |-- list.json (list of packages) [{"id":"core"},{"id":"smart-led"}]
+ *
+ *
+ * package.tar.gz contains:
+ *   package/
+ *     |-- dist/
+ *     |-- blocks/
+ *     |-- package.json
+ *     |-- README.md
+ */
+
+
+const RegistryListSchema = z.array(
+    z.object({
+        id: z.string(),
+    })
+);
+
+const RegistryVersionsSchema = z.array(
+    z.object({
+        version: z.string(),
+    })
+);
+
+export type RegistryList = z.infer<typeof RegistryListSchema>;
+export type RegistryVersions = z.infer<typeof RegistryVersionsSchema>;
+
+export function parseRegistryList(json: object): RegistryList {
+    const result = RegistryListSchema.safeParse(json);
+    if (!result.success) {
+        const pretty = z.prettifyError(result.error);
+        throw new Error(`Invalid registry list format:\n${pretty}`);
+    }
+    return result.data;
+}
+
+export function parseRegistryVersions(json: object): RegistryVersions {
+    const result = RegistryVersionsSchema.safeParse(json);
+    if (!result.success) {
+        const pretty = z.prettifyError(result.error);
+        throw new Error(`Invalid registry versions format:\n${pretty}`);
+    }
+    return result.data;
+}
+
+
 export class Registry {
     public registryUri: string[];
 
@@ -20,7 +77,7 @@ export class Registry {
             const allLibraries: Map<string, string> = new Map();
 
             for (const uri of this.registryUri) {
-                const libraries = await getRequestJson(this.getRequest, uri, "list.json");
+                const libraries = parseRegistryList(await getRequestJson(this.getRequest, uri, "list.json"));
                 for (const item of libraries) {
                     if (allLibraries.has(item.id)) {
                         throw new Error(
@@ -46,10 +103,10 @@ export class Registry {
     }
 
     public async listVersions(library: string): Promise<string[]> {
-        return this.retrieveSingleResultFromRegistries(async (uri) => {
-            const data = await getRequestJson(this.getRequest, uri, `${library}/versions.json`);
-            return data.map((item: any) => item.version).sort(semver.rcompare);
+        const versions = await this.retrieveSingleResultFromRegistries(async (uri) => {
+            return getRequestJson(this.getRequest, uri, `${library}/versions.json`);
         }, `Failed to fetch versions for library '${library}'`);
+        return parseRegistryVersions(versions).map((item) => item.version).sort(semver.rcompare);
     }
 
     public async getPackageJson(library: string, version: string): Promise<PackageJson> {