@resourcexjs/registry 2.5.0 → 2.5.1

package/dist/index.js

@@ -28,11 +28,10 @@ var EOF_BUFFER = new Uint8Array(BLOCK_SIZE * 2);
 var gzipAsync = promisify(gzip);
 function locate(rxm) {
   return {
-    domain: rxm.domain,
+    registry: rxm.registry,
     path: rxm.path,
     name: rxm.name,
-    type: rxm.type,
-    version: rxm.version
+    tag: rxm.tag
   };
 }
 function resource(rxm, rxa) {
@@ -45,56 +44,85 @@ function resource(rxm, rxa) {
 }
 var gunzipAsync = promisify2(gunzip);
 function format(rxl) {
-  let result = rxl.domain + "/";
+  let result = "";
+  if (rxl.registry) {
+    result += rxl.registry + "/";
+  }
   if (rxl.path) {
     result += rxl.path + "/";
   }
   result += rxl.name;
-  result += "." + rxl.type;
-  result += "@" + rxl.version;
+  if (rxl.tag && rxl.tag !== "latest") {
+    result += ":" + rxl.tag;
+  }
   return result;
 }
-function parse(locator) {
-  if (!locator || typeof locator !== "string") {
-    throw new LocatorError("locator must be a non-empty string", locator);
+function looksLikeRegistry(str) {
+  if (str.includes(":") && !str.includes("/")) {
+    return true;
   }
-  const atIndex = locator.lastIndexOf("@");
-  if (atIndex === -1) {
-    throw new LocatorError("locator must contain version (@)", locator);
+  if (str.includes(".")) {
+    return true;
   }
-  const version = locator.slice(atIndex + 1);
-  const beforeVersion = locator.slice(0, atIndex);
-  if (!version) {
-    throw new LocatorError("version is required", locator);
+  if (str === "localhost") {
+    return true;
   }
-  const dotIndex = beforeVersion.lastIndexOf(".");
-  if (dotIndex === -1) {
-    throw new LocatorError("locator must contain type (.)", locator);
+  return false;
+}
+function parse(locator) {
+  if (!locator || typeof locator !== "string") {
+    throw new LocatorError("Locator must be a non-empty string", locator);
+  }
+  if (locator.includes("@")) {
+    throw new LocatorError("Invalid locator format. Use name:tag instead of name@version", locator);
+  }
+  const lastSlashIndex = locator.lastIndexOf("/");
+  let beforeSlash = "";
+  let afterSlash = locator;
+  if (lastSlashIndex !== -1) {
+    beforeSlash = locator.substring(0, lastSlashIndex);
+    afterSlash = locator.substring(lastSlashIndex + 1);
+  }
+  const colonIndex = afterSlash.lastIndexOf(":");
+  let name;
+  let tag;
+  if (colonIndex === -1) {
+    name = afterSlash;
+    tag = "latest";
+  } else {
+    name = afterSlash.substring(0, colonIndex);
+    tag = afterSlash.substring(colonIndex + 1);
   }
-  const type = beforeVersion.slice(dotIndex + 1);
-  const beforeType = beforeVersion.slice(0, dotIndex);
-  if (!type) {
-    throw new LocatorError("type is required", locator);
+  if (!name) {
+    throw new LocatorError("Name is required", locator);
   }
-  const parts = beforeType.split("/");
-  if (parts.length < 2) {
-    throw new LocatorError("locator must contain domain", locator);
+  if (!tag) {
+    throw new LocatorError("Tag cannot be empty. Use name:tag format or omit tag for :latest", locator);
   }
-  const domain = parts[0];
-  const name = parts[parts.length - 1];
-  const path = parts.length > 2 ? parts.slice(1, -1).join("/") : undefined;
-  if (!domain) {
-    throw new LocatorError("domain is required", locator);
+  if (lastSlashIndex === -1) {
+    return {
+      registry: undefined,
+      path: undefined,
+      name,
+      tag
+    };
   }
-  if (!name) {
-    throw new LocatorError("name is required", locator);
+  const parts = beforeSlash.split("/");
+  if (looksLikeRegistry(parts[0])) {
+    const registry = parts[0];
+    const path = parts.length > 1 ? parts.slice(1).join("/") : undefined;
+    return {
+      registry,
+      path,
+      name,
+      tag
+    };
   }
   return {
-    domain,
-    path,
+    registry: undefined,
+    path: beforeSlash,
     name,
-    type,
-    version
+    tag
   };
 }
 
@@ -128,21 +156,19 @@ class RegistryError extends ResourceXError {
   }
 }
 
-// src/registries/HostedRegistry.ts
-class HostedRegistry {
+// src/registries/LocalRegistry.ts
+class LocalRegistry {
   storage;
   constructor(storage) {
     this.storage = storage;
   }
   buildKeyPrefix(rxl) {
-    const domain = rxl.domain ?? "localhost";
-    const resourceName = rxl.type ? `${rxl.name}.${rxl.type}` : rxl.name;
-    const version = rxl.version ?? "latest";
-    let key = domain;
+    const tag = rxl.tag ?? "latest";
+    let key = rxl.name;
     if (rxl.path) {
-      key += `/${rxl.path}`;
+      key = `${rxl.path}/${key}`;
     }
-    key += `/${resourceName}/${version}`;
+    key += `/${tag}`;
     return key;
   }
   async get(rxl) {
@@ -157,11 +183,11 @@ class HostedRegistry {
     }
     const manifestJson = JSON.parse(manifestData.toString("utf-8"));
     const rxm = {
-      domain: manifestJson.domain,
+      registry: manifestJson.registry,
       path: manifestJson.path,
       name: manifestJson.name,
       type: manifestJson.type,
-      version: manifestJson.version,
+      tag: manifestJson.tag,
       files: manifestJson.files
     };
     const archiveData = await this.storage.get(archiveKey);
@@ -173,11 +199,11 @@ class HostedRegistry {
     const manifestKey = `${prefix}/manifest.json`;
     const archiveKey = `${prefix}/archive.tar.gz`;
     const manifestJson = {
-      domain: rxr.manifest.domain,
+      registry: rxr.manifest.registry,
       path: rxr.manifest.path,
       name: rxr.manifest.name,
       type: rxr.manifest.type,
-      version: rxr.manifest.version,
+      tag: rxr.manifest.tag,
       files: rxr.manifest.files
     };
     const manifestData = Buffer.from(JSON.stringify(manifestJson, null, 2), "utf-8");
@@ -210,7 +236,7 @@ class HostedRegistry {
     if (query) {
       const lowerQuery = query.toLowerCase();
       filtered = locators.filter((rxl) => {
-        const searchText = `${rxl.domain ?? ""} ${rxl.path ?? ""} ${rxl.name} ${rxl.type ?? ""}`.toLowerCase();
+        const searchText = `${rxl.path ?? ""} ${rxl.name}`.toLowerCase();
         return searchText.includes(lowerQuery);
       });
     }
@@ -223,30 +249,18 @@ class HostedRegistry {
   parseKeyToRXL(key) {
     const dirPath = key.replace(/\/manifest\.json$/, "");
     const parts = dirPath.split("/");
-    if (parts.length < 3) {
+    if (parts.length < 2) {
       return null;
     }
-    const version = parts.pop();
-    const nameTypePart = parts.pop();
-    const domain = parts.shift();
+    const tag = parts.pop();
+    const name = parts.pop();
     const path = parts.length > 0 ? parts.join("/") : undefined;
-    const dotIndex = nameTypePart.lastIndexOf(".");
-    let name;
-    let type;
-    if (dotIndex !== -1) {
-      name = nameTypePart.substring(0, dotIndex);
-      type = nameTypePart.substring(dotIndex + 1);
-    } else {
-      name = nameTypePart;
-      type = undefined;
-    }
-    let locatorStr = domain;
+    let locatorStr = "";
     if (path)
-      locatorStr += `/${path}`;
-    locatorStr += `/${name}`;
-    if (type)
-      locatorStr += `.${type}`;
-    locatorStr += `@${version}`;
+      locatorStr += `${path}/`;
+    locatorStr += name;
+    if (tag !== "latest")
+      locatorStr += `:${tag}`;
     try {
       return parse(locatorStr);
     } catch {
@@ -261,14 +275,13 @@ class MirrorRegistry {
     this.storage = storage;
   }
   buildKeyPrefix(rxl) {
-    const domain = rxl.domain ?? "localhost";
-    const resourceName = rxl.type ? `${rxl.name}.${rxl.type}` : rxl.name;
-    const version = rxl.version ?? "latest";
-    let key = domain;
+    const registry = rxl.registry ?? "localhost";
+    const tag = rxl.tag ?? "latest";
+    let key = registry;
     if (rxl.path) {
       key += `/${rxl.path}`;
     }
-    key += `/${resourceName}/${version}`;
+    key += `/${rxl.name}/${tag}`;
     return key;
   }
   async get(rxl) {
@@ -283,11 +296,11 @@ class MirrorRegistry {
     }
     const manifestJson = JSON.parse(manifestData.toString("utf-8"));
     const rxm = {
-      domain: manifestJson.domain,
+      registry: manifestJson.registry,
       path: manifestJson.path,
       name: manifestJson.name,
       type: manifestJson.type,
-      version: manifestJson.version,
+      tag: manifestJson.tag,
       files: manifestJson.files
     };
     const archiveData = await this.storage.get(archiveKey);
@@ -299,11 +312,11 @@ class MirrorRegistry {
     const manifestKey = `${prefix}/manifest.json`;
     const archiveKey = `${prefix}/archive.tar.gz`;
     const manifestJson = {
-      domain: rxr.manifest.domain,
+      registry: rxr.manifest.registry,
       path: rxr.manifest.path,
       name: rxr.manifest.name,
       type: rxr.manifest.type,
-      version: rxr.manifest.version,
+      tag: rxr.manifest.tag,
       files: rxr.manifest.files
     };
     const manifestData = Buffer.from(JSON.stringify(manifestJson, null, 2), "utf-8");
@@ -336,7 +349,7 @@ class MirrorRegistry {
     if (query) {
       const lowerQuery = query.toLowerCase();
       filtered = locators.filter((rxl) => {
-        const searchText = `${rxl.domain ?? ""} ${rxl.path ?? ""} ${rxl.name} ${rxl.type ?? ""}`.toLowerCase();
+        const searchText = `${rxl.registry ?? ""} ${rxl.path ?? ""} ${rxl.name}`.toLowerCase();
         return searchText.includes(lowerQuery);
       });
     }
@@ -346,22 +359,22 @@ class MirrorRegistry {
     }
     return result;
   }
-  async clear(domain) {
-    if (domain) {
-      await this.storage.delete(domain);
+  async clear(registry) {
+    if (registry) {
+      await this.storage.delete(registry);
     } else {
       const allKeys = await this.storage.list();
-      const domains = new Set;
+      const registries = new Set;
       for (const key of allKeys) {
         const firstSlash = key.indexOf("/");
         if (firstSlash !== -1) {
-          domains.add(key.substring(0, firstSlash));
+          registries.add(key.substring(0, firstSlash));
         } else {
-          domains.add(key);
+          registries.add(key);
         }
       }
-      for (const d of domains) {
-        await this.storage.delete(d);
+      for (const r of registries) {
+        await this.storage.delete(r);
       }
     }
   }
@@ -371,27 +384,16 @@ class MirrorRegistry {
     if (parts.length < 3) {
       return null;
     }
-    const version = parts.pop();
-    const nameTypePart = parts.pop();
-    const domain = parts.shift();
+    const tag = parts.pop();
+    const name = parts.pop();
+    const registry = parts.shift();
     const path = parts.length > 0 ? parts.join("/") : undefined;
-    const dotIndex = nameTypePart.lastIndexOf(".");
-    let name;
-    let type;
-    if (dotIndex !== -1) {
-      name = nameTypePart.substring(0, dotIndex);
-      type = nameTypePart.substring(dotIndex + 1);
-    } else {
-      name = nameTypePart;
-      type = undefined;
-    }
-    let locatorStr = domain;
+    let locatorStr = registry;
     if (path)
       locatorStr += `/${path}`;
     locatorStr += `/${name}`;
-    if (type)
-      locatorStr += `.${type}`;
-    locatorStr += `@${version}`;
+    if (tag !== "latest")
+      locatorStr += `:${tag}`;
     try {
       return parse(locatorStr);
     } catch {
@@ -435,15 +437,16 @@ function define(input) {
   if (!obj.type || typeof obj.type !== "string") {
     throw new DefinitionError("type is required");
   }
-  if (!obj.version || typeof obj.version !== "string") {
-    throw new DefinitionError("version is required");
+  const tagValue = obj.tag ?? obj.version;
+  if (tagValue !== undefined && typeof tagValue !== "string") {
+    throw new DefinitionError("tag must be a string");
   }
   const rxd = {
     ...obj,
     name: obj.name,
     type: obj.type,
-    version: obj.version,
-    domain: typeof obj.domain === "string" ? obj.domain : "localhost",
+    tag: typeof tagValue === "string" ? tagValue : undefined,
+    registry: typeof obj.registry === "string" ? obj.registry : undefined,
     path: typeof obj.path === "string" ? obj.path : undefined,
     description: typeof obj.description === "string" ? obj.description : undefined,
     author: typeof obj.author === "string" ? obj.author : undefined,
@@ -455,11 +458,11 @@ function define(input) {
 }
 function manifest(rxd) {
   return {
-    domain: rxd.domain,
+    registry: rxd.registry,
     path: rxd.path,
     name: rxd.name,
     type: rxd.type,
-    version: rxd.version
+    tag: rxd.tag ?? "latest"
   };
 }
 var BLOCK_SIZE2 = 512;
@@ -888,11 +891,10 @@ async function archive(files) {
 }
 function locate2(rxm) {
   return {
-    domain: rxm.domain,
+    registry: rxm.registry,
     path: rxm.path,
     name: rxm.name,
-    type: rxm.type,
-    version: rxm.version
+    tag: rxm.tag
   };
 }
 function resource2(rxm, rxa) {
@@ -977,14 +979,13 @@ class LinkedRegistry {
     this.basePath = basePath;
   }
   buildLinkPath(rxl) {
-    const domain = rxl.domain ?? "localhost";
-    const resourceName = rxl.type ? `${rxl.name}.${rxl.type}` : rxl.name;
-    const version = rxl.version ?? "latest";
-    let linkPath = join2(this.basePath, domain);
+    const registry = rxl.registry ?? "localhost";
+    const tag = rxl.tag ?? "latest";
+    let linkPath = join2(this.basePath, registry);
     if (rxl.path) {
       linkPath = join2(linkPath, rxl.path);
     }
-    return join2(linkPath, resourceName, version);
+    return join2(linkPath, rxl.name, tag);
   }
   async isSymlink(path) {
     try {
@@ -1027,7 +1028,7 @@ class LinkedRegistry {
     if (query) {
       const lowerQuery = query.toLowerCase();
       filtered = locators.filter((rxl) => {
-        const searchText = `${rxl.domain ?? ""} ${rxl.path ?? ""} ${rxl.name} ${rxl.type ?? ""}`.toLowerCase();
+        const searchText = `${rxl.registry ?? ""} ${rxl.path ?? ""} ${rxl.name}`.toLowerCase();
         return searchText.includes(lowerQuery);
       });
     }
@@ -1083,27 +1084,16 @@ class LinkedRegistry {
     if (parts.length < 3) {
       return null;
     }
-    const version = parts.pop();
-    const nameTypePart = parts.pop();
-    const domain = parts.shift();
+    const tag = parts.pop();
+    const name = parts.pop();
+    const registry = parts.shift();
     const path = parts.length > 0 ? parts.join("/") : undefined;
-    const dotIndex = nameTypePart.lastIndexOf(".");
-    let name;
-    let type;
-    if (dotIndex !== -1) {
-      name = nameTypePart.substring(0, dotIndex);
-      type = nameTypePart.substring(dotIndex + 1);
-    } else {
-      name = nameTypePart;
-      type = undefined;
-    }
-    let locatorStr = domain;
+    let locatorStr = registry;
     if (path)
       locatorStr += `/${path}`;
     locatorStr += `/${name}`;
-    if (type)
-      locatorStr += `.${type}`;
-    locatorStr += `@${version}`;
+    if (tag !== "latest")
+      locatorStr += `:${tag}`;
     try {
       return parse(locatorStr);
     } catch {
@@ -1111,6 +1101,116 @@ class LinkedRegistry {
     }
   }
 }
+// src/chain/RegistryAccessChain.ts
+class RegistryAccessChain {
+  accessors;
+  memCache = new Map;
+  useMemCache;
+  constructor(accessors, options) {
+    this.accessors = accessors;
+    this.useMemCache = options?.memCache ?? false;
+  }
+  async get(rxl) {
+    const key = format(rxl);
+    if (this.useMemCache && this.memCache.has(key)) {
+      return this.memCache.get(key);
+    }
+    for (const accessor of this.accessors) {
+      if (await accessor.canHandle(rxl)) {
+        const rxr = await accessor.get(rxl);
+        if (this.useMemCache && accessor.name !== "linked") {
+          this.memCache.set(key, rxr);
+        }
+        return rxr;
+      }
+    }
+    throw new RegistryError(`Resource not found: ${key}`);
+  }
+  async has(rxl) {
+    const key = format(rxl);
+    if (this.useMemCache && this.memCache.has(key)) {
+      return true;
+    }
+    for (const accessor of this.accessors) {
+      if (await accessor.canHandle(rxl)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  clearCache() {
+    this.memCache.clear();
+  }
+  invalidate(rxl) {
+    this.memCache.delete(format(rxl));
+  }
+}
+// src/chain/LinkedAccessor.ts
+class LinkedAccessor {
+  registry;
+  name = "linked";
+  constructor(registry) {
+    this.registry = registry;
+  }
+  async canHandle(rxl) {
+    return this.registry.has(rxl);
+  }
+  async get(rxl) {
+    return this.registry.get(rxl);
+  }
+}
+// src/chain/LocalAccessor.ts
+class LocalAccessor {
+  registry;
+  name = "local";
+  constructor(registry) {
+    this.registry = registry;
+  }
+  async canHandle(rxl) {
+    if (rxl.registry) {
+      return false;
+    }
+    return this.registry.has(rxl);
+  }
+  async get(rxl) {
+    return this.registry.get(rxl);
+  }
+}
+// src/chain/CacheAccessor.ts
+class CacheAccessor {
+  registry;
+  name = "cache";
+  constructor(registry) {
+    this.registry = registry;
+  }
+  async canHandle(rxl) {
+    if (!rxl.registry) {
+      return false;
+    }
+    return this.registry.has(rxl);
+  }
+  async get(rxl) {
+    return this.registry.get(rxl);
+  }
+}
+// src/chain/RemoteAccessor.ts
+class RemoteAccessor {
+  fetcher;
+  cache;
+  name = "remote";
+  constructor(fetcher, cache) {
+    this.fetcher = fetcher;
+    this.cache = cache;
+  }
+  async canHandle(rxl) {
+    return !!rxl.registry;
+  }
+  async get(rxl) {
+    const rxr = await this.fetcher.fetch(rxl);
+    await this.cache.put(rxr);
+    return rxr;
+  }
+}
 // src/discovery.ts
 async function discoverRegistry(domain) {
   const wellKnownUrl = `https://${domain}/.well-known/resourcex`;
@@ -1157,35 +1257,42 @@ class RegistryMiddleware {
   }
 }
 // src/middleware/DomainValidation.ts
-class DomainValidation extends RegistryMiddleware {
-  trustedDomain;
-  constructor(inner, trustedDomain) {
+class RegistryValidation extends RegistryMiddleware {
+  trustedRegistry;
+  constructor(inner, trustedRegistry) {
     super(inner);
-    this.trustedDomain = trustedDomain;
+    this.trustedRegistry = trustedRegistry;
   }
-  validateDomain(rxr) {
-    if (rxr.manifest.domain !== this.trustedDomain) {
-      throw new RegistryError(`Untrusted domain: resource claims "${rxr.manifest.domain}" but registry only trusts "${this.trustedDomain}"`);
+  validateRegistry(rxr) {
+    if (rxr.manifest.registry !== this.trustedRegistry) {
+      throw new RegistryError(`Untrusted registry: resource claims "${rxr.manifest.registry}" but registry only trusts "${this.trustedRegistry}"`);
     }
   }
   async get(rxl) {
     const rxr = await this.inner.get(rxl);
-    this.validateDomain(rxr);
+    this.validateRegistry(rxr);
     return rxr;
   }
 }
-function withDomainValidation(registry, trustedDomain) {
-  return new DomainValidation(registry, trustedDomain);
+function withRegistryValidation(registry, trustedRegistry) {
+  return new RegistryValidation(registry, trustedRegistry);
 }
+var DomainValidation = RegistryValidation;
+var withDomainValidation = withRegistryValidation;
 export {
   withDomainValidation,
   discoverRegistry,
+  RemoteAccessor,
   RegistryMiddleware,
   RegistryError,
+  RegistryAccessChain,
   MirrorRegistry,
+  LocalRegistry,
+  LocalAccessor,
   LinkedRegistry,
-  HostedRegistry,
-  DomainValidation
+  LinkedAccessor,
+  DomainValidation,
+  CacheAccessor
 };
 
-//# debugId=AA55A49BFF3626F564756E2164756E21
+//# debugId=94E483D2C901ABA364756E2164756E21