@resourcexjs/core 2.8.0 → 2.10.0

package/dist/index.js

@@ -14647,37 +14647,46 @@ async function extract(rxa) {
   return files;
 }
 // src/model/format.ts
-function format(rxl) {
+function format(rxi) {
   let result = "";
-  if (rxl.registry) {
-    result += `${rxl.registry}/`;
+  if (rxi.registry) {
+    result += `${rxi.registry}/`;
   }
-  if (rxl.path) {
-    result += `${rxl.path}/`;
+  if (rxi.path) {
+    result += `${rxi.path}/`;
   }
-  result += rxl.name;
-  if (rxl.tag && rxl.tag !== "latest") {
-    result += `:${rxl.tag}`;
+  result += rxi.name;
+  if (rxi.tag && rxi.tag !== "latest") {
+    result += `:${rxi.tag}`;
   }
   return result;
 }
 // src/model/locate.ts
 function locate(rxm) {
   return {
-    registry: rxm.registry,
-    path: rxm.path,
-    name: rxm.name,
-    tag: rxm.tag
+    registry: rxm.definition.registry,
+    path: rxm.definition.path,
+    name: rxm.definition.name,
+    tag: rxm.definition.tag
   };
 }
 // src/model/manifest.ts
 function manifest(rxd) {
   return {
-    registry: rxd.registry,
-    path: rxd.path,
-    name: rxd.name,
-    type: rxd.type,
-    tag: rxd.tag ?? "latest"
+    definition: {
+      name: rxd.name,
+      type: rxd.type,
+      tag: rxd.tag ?? "latest",
+      registry: rxd.registry,
+      path: rxd.path,
+      description: rxd.description,
+      author: rxd.author,
+      license: rxd.license,
+      keywords: rxd.keywords,
+      repository: rxd.repository
+    },
+    archive: {},
+    source: {}
   };
 }
 // src/model/parse.ts
@@ -14782,9 +14791,9 @@ function parse5(locator) {
 }
 // src/model/resource.ts
 function resource(rxm, rxa) {
-  const rxl = locate(rxm);
+  const rxi = locate(rxm);
   return {
-    locator: rxl,
+    identifier: rxi,
     manifest: rxm,
     archive: rxa
   };
@@ -15193,17 +15202,17 @@ class RegistryMiddleware {
   constructor(inner) {
     this.inner = inner;
   }
-  get(rxl) {
-    return this.inner.get(rxl);
+  get(rxi) {
+    return this.inner.get(rxi);
   }
   put(rxr) {
     return this.inner.put(rxr);
   }
-  has(rxl) {
-    return this.inner.has(rxl);
+  has(rxi) {
+    return this.inner.has(rxi);
   }
-  remove(rxl) {
-    return this.inner.remove(rxl);
+  remove(rxi) {
+    return this.inner.remove(rxi);
   }
   list(options) {
     return this.inner.list(options);
@@ -15218,12 +15227,12 @@ class RegistryValidation extends RegistryMiddleware {
     this.trustedRegistry = trustedRegistry;
   }
   validateRegistry(rxr) {
-    if (rxr.manifest.registry !== this.trustedRegistry) {
-      throw new RegistryError(`Untrusted registry: resource claims "${rxr.manifest.registry}" but registry only trusts "${this.trustedRegistry}"`);
+    if (rxr.manifest.definition.registry !== this.trustedRegistry) {
+      throw new RegistryError(`Untrusted registry: resource claims "${rxr.manifest.definition.registry}" but registry only trusts "${this.trustedRegistry}"`);
     }
   }
-  async get(rxl) {
-    const rxr = await this.inner.get(rxl);
+  async get(rxi) {
+    const rxr = await this.inner.get(rxi);
     this.validateRegistry(rxr);
     return rxr;
   }
@@ -15252,23 +15261,31 @@ class CASRegistry {
     }
     return tag;
   }
-  async get(rxl) {
-    const tag = await this.resolveTag(rxl.name, rxl.tag ?? "latest", rxl.registry);
-    const storedRxm = await this.rxmStore.get(rxl.name, tag, rxl.registry);
+  async get(rxi) {
+    const tag = await this.resolveTag(rxi.name, rxi.tag ?? "latest", rxi.registry);
+    const storedRxm = await this.rxmStore.get(rxi.name, tag, rxi.registry);
     if (!storedRxm) {
-      throw new RegistryError(`Resource not found: ${format(rxl)}`);
+      throw new RegistryError(`Resource not found: ${format(rxi)}`);
     }
     const files = {};
     for (const [filename, digest] of Object.entries(storedRxm.files)) {
       files[filename] = await this.rxaStore.get(digest);
     }
     const rxm = {
-      registry: storedRxm.registry,
-      path: storedRxm.path,
-      name: storedRxm.name,
-      type: storedRxm.type,
-      tag: storedRxm.tag,
-      files: Object.keys(storedRxm.files)
+      definition: {
+        registry: storedRxm.registry,
+        path: storedRxm.path,
+        name: storedRxm.name,
+        type: storedRxm.type,
+        tag: storedRxm.tag,
+        description: storedRxm.description,
+        author: storedRxm.author,
+        license: storedRxm.license,
+        keywords: storedRxm.keywords,
+        repository: storedRxm.repository
+      },
+      archive: {},
+      source: {}
     };
     const rxa = await archive(files);
     return resource(rxm, rxa);
@@ -15281,25 +15298,30 @@ class CASRegistry {
       fileDigests[filename] = digest;
     }
     const storedRxm = {
-      registry: rxr.manifest.registry,
-      path: rxr.manifest.path,
-      name: rxr.manifest.name,
-      type: rxr.manifest.type,
-      tag: rxr.manifest.tag,
+      registry: rxr.manifest.definition.registry,
+      path: rxr.manifest.definition.path,
+      name: rxr.manifest.definition.name,
+      type: rxr.manifest.definition.type,
+      tag: rxr.manifest.definition.tag,
+      description: rxr.manifest.definition.description,
+      author: rxr.manifest.definition.author,
+      license: rxr.manifest.definition.license,
+      keywords: rxr.manifest.definition.keywords,
+      repository: rxr.manifest.definition.repository,
       files: fileDigests,
       createdAt: new Date,
       updatedAt: new Date
     };
     await this.rxmStore.put(storedRxm);
-    await this.rxmStore.setLatest(rxr.manifest.name, rxr.manifest.tag, rxr.manifest.registry);
+    await this.rxmStore.setLatest(rxr.manifest.definition.name, rxr.manifest.definition.tag, rxr.manifest.definition.registry);
   }
-  async has(rxl) {
-    const tag = await this.resolveTag(rxl.name, rxl.tag ?? "latest", rxl.registry);
-    return this.rxmStore.has(rxl.name, tag, rxl.registry);
+  async has(rxi) {
+    const tag = await this.resolveTag(rxi.name, rxi.tag ?? "latest", rxi.registry);
+    return this.rxmStore.has(rxi.name, tag, rxi.registry);
   }
-  async remove(rxl) {
-    const tag = rxl.tag ?? "latest";
-    await this.rxmStore.delete(rxl.name, tag, rxl.registry);
+  async remove(rxi) {
+    const tag = rxi.tag ?? "latest";
+    await this.rxmStore.delete(rxi.name, tag, rxi.registry);
   }
   async list(options) {
     const { query, limit, offset = 0 } = options ?? {};
@@ -15363,14 +15385,14 @@ class LinkedRegistry {
   constructor(basePath) {
     this.basePath = basePath;
   }
-  buildLinkPath(rxl) {
-    const registry2 = rxl.registry ?? "localhost";
-    const tag = rxl.tag ?? "latest";
+  buildLinkPath(rxi) {
+    const registry2 = rxi.registry ?? "localhost";
+    const tag = rxi.tag ?? "latest";
     let linkPath = join3(this.basePath, registry2);
-    if (rxl.path) {
-      linkPath = join3(linkPath, rxl.path);
+    if (rxi.path) {
+      linkPath = join3(linkPath, rxi.path);
     }
-    return join3(linkPath, rxl.name, tag);
+    return join3(linkPath, rxi.name, tag);
   }
   async isSymlink(path) {
     try {
@@ -15380,10 +15402,10 @@ class LinkedRegistry {
       return false;
     }
   }
-  async get(rxl) {
-    const linkPath = this.buildLinkPath(rxl);
+  async get(rxi) {
+    const linkPath = this.buildLinkPath(rxi);
     if (!await this.isSymlink(linkPath)) {
-      throw new RegistryError(`Linked resource not found: ${format(rxl)}`);
+      throw new RegistryError(`Linked resource not found: ${format(rxi)}`);
     }
     const targetPath = await readlink(linkPath);
     return loadResource(targetPath);
@@ -15391,29 +15413,29 @@ class LinkedRegistry {
   async put(_rxr) {
     throw new RegistryError("LinkedRegistry does not support put(). Use link() instead.");
   }
-  async has(rxl) {
-    const linkPath = this.buildLinkPath(rxl);
+  async has(rxi) {
+    const linkPath = this.buildLinkPath(rxi);
     return this.isSymlink(linkPath);
   }
-  async remove(rxl) {
-    const linkPath = this.buildLinkPath(rxl);
+  async remove(rxi) {
+    const linkPath = this.buildLinkPath(rxi);
     if (await this.isSymlink(linkPath)) {
       await rm(linkPath);
     }
   }
   async list(options) {
     const { query, limit, offset = 0 } = options ?? {};
-    const locators = [];
+    const identifiers = [];
     try {
-      await this.scanSymlinks(this.basePath, "", locators);
+      await this.scanSymlinks(this.basePath, "", identifiers);
     } catch {
       return [];
     }
-    let filtered = locators;
+    let filtered = identifiers;
     if (query) {
       const lowerQuery = query.toLowerCase();
-      filtered = locators.filter((rxl) => {
-        const searchText = `${rxl.registry ?? ""} ${rxl.path ?? ""} ${rxl.name}`.toLowerCase();
+      filtered = identifiers.filter((rxi) => {
+        const searchText = `${rxi.registry ?? ""} ${rxi.path ?? ""} ${rxi.name}`.toLowerCase();
         return searchText.includes(lowerQuery);
       });
     }
@@ -15425,7 +15447,7 @@ class LinkedRegistry {
   }
   async link(devPath) {
     const rxr = await loadResource(devPath);
-    const linkPath = this.buildLinkPath(rxr.locator);
+    const linkPath = this.buildLinkPath(rxr.identifier);
     try {
       const stats = await lstat(linkPath);
       if (stats.isSymbolicLink() || stats.isDirectory()) {
@@ -15436,12 +15458,12 @@ class LinkedRegistry {
     await mkdir(parentPath, { recursive: true });
     const absolutePath = resolvePath(devPath);
     await symlink(absolutePath, linkPath);
-    return rxr.locator;
+    return rxr.identifier;
   }
-  async unlink(rxl) {
-    return this.remove(rxl);
+  async unlink(rxi) {
+    return this.remove(rxi);
   }
-  async scanSymlinks(dirPath, relativePath, locators) {
+  async scanSymlinks(dirPath, relativePath, identifiers) {
     let entries;
     try {
       entries = await readdir3(dirPath);
@@ -15454,17 +15476,17 @@ class LinkedRegistry {
       try {
         const stats = await lstat(fullPath);
         if (stats.isSymbolicLink()) {
-          const rxl = this.parsePathToRXL(relPath);
-          if (rxl) {
-            locators.push(rxl);
+          const rxi = this.parsePathToRXI(relPath);
+          if (rxi) {
+            identifiers.push(rxi);
           }
         } else if (stats.isDirectory()) {
-          await this.scanSymlinks(fullPath, relPath, locators);
+          await this.scanSymlinks(fullPath, relPath, identifiers);
         }
       } catch {}
     }
   }
-  parsePathToRXL(relPath) {
+  parsePathToRXI(relPath) {
     const parts = relPath.split("/");
     if (parts.length < 3) {
       return null;
@@ -15842,4 +15864,4 @@ export {
   CASRegistry
 };
 
-//# debugId=7C301A1A890CF92B64756E2164756E21
+//# debugId=8AF33945E518861764756E2164756E21