@resourcexjs/registry 1.6.0 → 1.7.0

package/dist/index.js

@@ -1,3 +1,7 @@
+// src/types.ts
+function isRemoteConfig(config) {
+  return config !== undefined && "endpoint" in config;
+}
 // ../core/dist/index.js
 import { gzip, gunzip } from "node:zlib";
 import { promisify } from "node:util";
@@ -156,8 +160,10 @@ class RegistryError extends ResourceXError {
     this.name = "RegistryError";
   }
 }
-// src/ARPRegistry.ts
+// src/LocalRegistry.ts
 import { homedir } from "node:os";
+import { join } from "node:path";
+import { readFile, writeFile, mkdir, rm, stat, readdir } from "node:fs/promises";
 
 // ../type/dist/index.js
 import { gzip as gzip2, gunzip as gunzip2 } from "node:zlib";
@@ -1459,487 +1465,13 @@ class TypeHandlerChain {
   }
 }
 
-// ../arp/dist/index.js
-import { readFile, writeFile, readdir, mkdir, rm, access, stat } from "node:fs/promises";
-import { resolve, dirname, join } from "node:path";
-
-class ARPError extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "ARPError";
-  }
-}
-
-class ParseError extends ARPError {
-  url;
-  constructor(message, url) {
-    super(message);
-    this.url = url;
-    this.name = "ParseError";
-  }
-}
-
-class TransportError extends ARPError {
-  transport;
-  constructor(message, transport, options) {
-    super(message, options);
-    this.transport = transport;
-    this.name = "TransportError";
-  }
-}
-
-class SemanticError extends ARPError {
-  semantic;
-  constructor(message, semantic, options) {
-    super(message, options);
-    this.semantic = semantic;
-    this.name = "SemanticError";
-  }
-}
-
-class ARL {
-  semantic;
-  transport;
-  location;
-  resolver;
-  constructor(semantic, transport, location, resolver) {
-    this.semantic = semantic;
-    this.transport = transport;
-    this.location = location;
-    this.resolver = resolver;
-  }
-  createContext(params) {
-    return {
-      url: this.toString(),
-      semantic: this.semantic,
-      transport: this.transport,
-      location: this.location,
-      timestamp: new Date,
-      params
-    };
-  }
-  async resolve(params) {
-    const transport = this.resolver.getTransportHandler(this.transport);
-    const semantic = this.resolver.getSemanticHandler(this.semantic);
-    const context = this.createContext(params);
-    return semantic.resolve(transport, this.location, context);
-  }
-  async deposit(data, params) {
-    const transport = this.resolver.getTransportHandler(this.transport);
-    const semantic = this.resolver.getSemanticHandler(this.semantic);
-    const context = this.createContext(params);
-    if (!semantic.deposit) {
-      throw new SemanticError(`Semantic "${semantic.name}" does not support deposit operation`, this.semantic);
-    }
-    await semantic.deposit(transport, this.location, data, context);
-  }
-  async exists() {
-    const transport = this.resolver.getTransportHandler(this.transport);
-    const semantic = this.resolver.getSemanticHandler(this.semantic);
-    const context = this.createContext();
-    if (semantic.exists) {
-      return semantic.exists(transport, this.location, context);
-    }
-    return transport.exists(this.location);
-  }
-  async delete() {
-    const transport = this.resolver.getTransportHandler(this.transport);
-    const semantic = this.resolver.getSemanticHandler(this.semantic);
-    const context = this.createContext();
-    if (semantic.delete) {
-      return semantic.delete(transport, this.location, context);
-    }
-    await transport.delete(this.location);
-  }
-  toString() {
-    return `arp:${this.semantic}:${this.transport}://${this.location}`;
-  }
-}
-
-class FileTransportHandler {
-  name = "file";
-  resolvePath(location) {
-    return resolve(process.cwd(), location);
-  }
-  async get(location, params) {
-    const filePath = this.resolvePath(location);
-    try {
-      const stats = await stat(filePath);
-      if (stats.isDirectory()) {
-        return this.getDirectory(filePath, stats, params);
-      } else {
-        return this.getFile(filePath, stats);
-      }
-    } catch (error) {
-      const err = error;
-      throw new TransportError(`File get error: ${err.code} - ${filePath}`, this.name, {
-        cause: err
-      });
-    }
-  }
-  async getFile(filePath, stats) {
-    const content = await readFile(filePath);
-    return {
-      content,
-      metadata: {
-        type: "file",
-        size: Number(stats.size),
-        modifiedAt: stats.mtime
-      }
-    };
-  }
-  async getDirectory(dirPath, stats, params) {
-    const recursive = params?.recursive === "true";
-    const pattern = params?.pattern;
-    let entries;
-    if (recursive) {
-      entries = await this.listRecursive(dirPath, dirPath);
-    } else {
-      entries = await readdir(dirPath);
-    }
-    if (pattern) {
-      entries = this.filterByPattern(entries, pattern);
-    }
-    const content = Buffer.from(JSON.stringify(entries));
-    return {
-      content,
-      metadata: {
-        type: "directory",
-        modifiedAt: stats.mtime
-      }
-    };
-  }
-  async listRecursive(basePath, currentPath) {
-    const entries = await readdir(currentPath, { withFileTypes: true });
-    const results = [];
-    for (const entry of entries) {
-      const fullPath = join(currentPath, entry.name);
-      const relativePath = fullPath.substring(basePath.length + 1);
-      if (entry.isDirectory()) {
-        const subEntries = await this.listRecursive(basePath, fullPath);
-        results.push(...subEntries);
-      } else {
-        results.push(relativePath);
-      }
-    }
-    return results;
-  }
-  filterByPattern(entries, pattern) {
-    const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".");
-    const regex = new RegExp(`^${regexPattern}$`);
-    return entries.filter((entry) => {
-      const filename = entry.split("/").pop() || entry;
-      return regex.test(filename);
-    });
-  }
-  async set(location, content, _params) {
-    const filePath = this.resolvePath(location);
-    try {
-      await mkdir(dirname(filePath), { recursive: true });
-      await writeFile(filePath, content);
-    } catch (error) {
-      const err = error;
-      throw new TransportError(`File set error: ${err.code} - ${filePath}`, this.name, {
-        cause: err
-      });
-    }
-  }
-  async exists(location) {
-    const filePath = this.resolvePath(location);
-    try {
-      await access(filePath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async delete(location) {
-    const filePath = this.resolvePath(location);
-    try {
-      await rm(filePath, { recursive: true });
-    } catch (error) {
-      const err = error;
-      if (err.code === "ENOENT") {
-        return;
-      }
-      throw new TransportError(`File delete error: ${err.code} - ${filePath}`, this.name, {
-        cause: err
-      });
-    }
-  }
-}
-var fileTransport = new FileTransportHandler;
-
-class HttpTransportHandler {
-  name;
-  protocol;
-  constructor(protocol = "https") {
-    this.protocol = protocol;
-    this.name = protocol;
-  }
-  async get(location, params) {
-    const url = this.buildUrl(location, params);
-    try {
-      const response = await fetch(url);
-      if (!response.ok) {
-        throw new TransportError(`HTTP ${response.status}: ${response.statusText} - ${url}`, this.name);
-      }
-      const arrayBuffer = await response.arrayBuffer();
-      const content = Buffer.from(arrayBuffer);
-      const contentType = response.headers.get("content-type");
-      const contentLength = response.headers.get("content-length");
-      const lastModified = response.headers.get("last-modified");
-      return {
-        content,
-        metadata: {
-          type: "file",
-          size: contentLength ? parseInt(contentLength, 10) : content.length,
-          modifiedAt: lastModified ? new Date(lastModified) : undefined,
-          contentType
-        }
-      };
-    } catch (error) {
-      if (error instanceof TransportError) {
-        throw error;
-      }
-      throw new TransportError(`Network error: ${url}`, this.name, {
-        cause: error
-      });
-    }
-  }
-  buildUrl(location, params) {
-    const url = new URL(`${this.protocol}://${location}`);
-    if (params) {
-      for (const [key, value] of Object.entries(params)) {
-        url.searchParams.set(key, value);
-      }
-    }
-    return url.toString();
-  }
-  async set(_location, _content, _params) {
-    throw new TransportError("HTTP transport is read-only, set not supported", this.name);
-  }
-  async exists(location) {
-    const url = `${this.protocol}://${location}`;
-    try {
-      const response = await fetch(url, { method: "HEAD" });
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-  async delete(_location) {
-    throw new TransportError("HTTP transport is read-only, delete not supported", this.name);
-  }
-}
-var httpsTransport = new HttpTransportHandler("https");
-var httpTransport = new HttpTransportHandler("http");
-
-class TextSemanticHandler {
-  name = "text";
-  async resolve(transport, location, context) {
-    const result = await transport.get(location, context.params);
-    if (result.metadata?.type === "directory") {
-      const meta2 = {
-        url: context.url,
-        semantic: context.semantic,
-        transport: context.transport,
-        location: context.location,
-        size: result.content.length,
-        encoding: "utf-8",
-        mimeType: "application/json",
-        resolvedAt: context.timestamp.toISOString(),
-        type: "directory"
-      };
-      return {
-        type: "text",
-        content: result.content.toString("utf-8"),
-        meta: meta2
-      };
-    }
-    const text = result.content.toString("utf-8");
-    const meta = {
-      url: context.url,
-      semantic: context.semantic,
-      transport: context.transport,
-      location: context.location,
-      size: result.metadata?.size ?? result.content.length,
-      encoding: "utf-8",
-      mimeType: "text/plain",
-      resolvedAt: context.timestamp.toISOString(),
-      type: "file"
-    };
-    return {
-      type: "text",
-      content: text,
-      meta
-    };
-  }
-  async deposit(transport, location, data, context) {
-    const buffer = Buffer.from(data, "utf-8");
-    try {
-      await transport.set(location, buffer, context.params);
-    } catch (error) {
-      throw new SemanticError(`Failed to deposit text to "${location}": ${error.message}`, this.name, { cause: error });
-    }
-  }
-  async exists(transport, location, _context) {
-    return transport.exists(location);
-  }
-  async delete(transport, location, _context) {
-    try {
-      await transport.delete(location);
-    } catch (error) {
-      throw new SemanticError(`Failed to delete "${location}": ${error.message}`, this.name, { cause: error });
-    }
-  }
-}
-var textSemantic = new TextSemanticHandler;
-function toBuffer(data) {
-  if (Buffer.isBuffer(data)) {
-    return data;
-  }
-  if (data instanceof Uint8Array) {
-    return Buffer.from(data);
-  }
-  if (data instanceof ArrayBuffer) {
-    return Buffer.from(data);
-  }
-  if (Array.isArray(data)) {
-    return Buffer.from(data);
-  }
-  throw new SemanticError(`Unsupported binary input type`, "binary");
-}
-
-class BinarySemanticHandler {
-  name = "binary";
-  async resolve(transport, location, context) {
-    const result = await transport.get(location, context.params);
-    const meta = {
-      url: context.url,
-      semantic: context.semantic,
-      transport: context.transport,
-      location: context.location,
-      size: result.metadata?.size ?? result.content.length,
-      resolvedAt: context.timestamp.toISOString(),
-      type: result.metadata?.type
-    };
-    return {
-      type: "binary",
-      content: result.content,
-      meta
-    };
-  }
-  async deposit(transport, location, data, context) {
-    const buffer = toBuffer(data);
-    try {
-      await transport.set(location, buffer, context.params);
-    } catch (error) {
-      throw new SemanticError(`Failed to deposit binary to "${location}": ${error.message}`, this.name, { cause: error });
-    }
-  }
-  async exists(transport, location, _context) {
-    return transport.exists(location);
-  }
-  async delete(transport, location, _context) {
-    try {
-      await transport.delete(location);
-    } catch (error) {
-      throw new SemanticError(`Failed to delete "${location}": ${error.message}`, this.name, { cause: error });
-    }
-  }
-}
-var binarySemantic = new BinarySemanticHandler;
-
-class ARP {
-  transports;
-  semantics;
-  constructor(config = {}) {
-    this.transports = new Map;
-    this.semantics = new Map;
-    const defaultTransports = [fileTransport, httpTransport, httpsTransport];
-    const defaultSemantics = [textSemantic, binarySemantic];
-    for (const handler of defaultTransports) {
-      this.transports.set(handler.name, handler);
-    }
-    for (const handler of defaultSemantics) {
-      this.semantics.set(handler.name, handler);
-    }
-    if (config.transports) {
-      for (const handler of config.transports) {
-        this.transports.set(handler.name, handler);
-      }
-    }
-    if (config.semantics) {
-      for (const handler of config.semantics) {
-        this.semantics.set(handler.name, handler);
-      }
-    }
-  }
-  registerTransport(handler) {
-    this.transports.set(handler.name, handler);
-  }
-  registerSemantic(handler) {
-    this.semantics.set(handler.name, handler);
-  }
-  getTransportHandler(name) {
-    const handler = this.transports.get(name);
-    if (!handler) {
-      throw new TransportError(`Unsupported transport type: ${name}`, name);
-    }
-    return handler;
-  }
-  getSemanticHandler(name) {
-    const handler = this.semantics.get(name);
-    if (!handler) {
-      throw new SemanticError(`Unsupported semantic type: ${name}`, name);
-    }
-    return handler;
-  }
-  parse(url) {
-    if (!url.startsWith("arp:")) {
-      throw new ParseError(`Invalid ARP URL: must start with "arp:"`, url);
-    }
-    const content = url.substring(4);
-    const separatorIndex = content.indexOf("://");
-    if (separatorIndex === -1) {
-      throw new ParseError(`Invalid ARP URL: missing "://"`, url);
-    }
-    const typePart = content.substring(0, separatorIndex);
-    const location = content.substring(separatorIndex + 3);
-    const colonIndex = typePart.indexOf(":");
-    if (colonIndex === -1) {
-      throw new ParseError(`Invalid ARP URL: must have exactly 2 types (semantic:transport)`, url);
-    }
-    const semantic = typePart.substring(0, colonIndex);
-    const transport = typePart.substring(colonIndex + 1);
-    if (!semantic) {
-      throw new ParseError(`Invalid ARP URL: semantic type cannot be empty`, url);
-    }
-    if (!transport) {
-      throw new ParseError(`Invalid ARP URL: transport type cannot be empty`, url);
-    }
-    if (!location) {
-      throw new ParseError(`Invalid ARP URL: location cannot be empty`, url);
-    }
-    this.getTransportHandler(transport);
-    this.getSemanticHandler(semantic);
-    return new ARL(semantic, transport, location, this);
-  }
-}
-function createARP(config) {
-  return new ARP(config);
-}
-
-// src/ARPRegistry.ts
+// src/LocalRegistry.ts
 var DEFAULT_PATH = `${homedir()}/.resourcex`;
 
-class ARPRegistry {
-  arp;
+class LocalRegistry {
   basePath;
   typeHandler;
   constructor(config) {
-    this.arp = createARP();
     this.basePath = config?.path ?? DEFAULT_PATH;
     this.typeHandler = TypeHandlerChain.create();
     if (config?.types) {
@@ -1951,79 +1483,79 @@ class ARPRegistry {
   supportType(type) {
     this.typeHandler.register(type);
   }
-  buildUrl(locator, filename) {
+  buildPath(locator) {
     const rxl = typeof locator === "string" ? parseRXL(locator) : locator;
     const domain = rxl.domain ?? "localhost";
     const version = rxl.version ?? "latest";
-    let path = `${this.basePath}/${domain}`;
+    let path = join(this.basePath, domain);
     if (rxl.path) {
-      path += `/${rxl.path}`;
+      path = join(path, rxl.path);
     }
     const resourceName = rxl.type ? `${rxl.name}.${rxl.type}` : rxl.name;
-    return `arp:text:file://${path}/${resourceName}/${version}/${filename}`;
+    return join(path, resourceName, version);
   }
   async publish(_resource) {
     throw new RegistryError("Remote publish not implemented yet");
   }
   async link(resource) {
     const locator = resource.manifest.toLocator();
-    const manifestUrl = this.buildUrl(locator, "manifest.json");
-    const manifestArl = this.arp.parse(manifestUrl);
-    await manifestArl.deposit(JSON.stringify(resource.manifest.toJSON(), null, 2));
-    const contentUrl = this.buildUrl(locator, "content.tar.gz").replace("arp:text:", "arp:binary:");
-    const contentArl = this.arp.parse(contentUrl);
+    const resourcePath = this.buildPath(locator);
+    await mkdir(resourcePath, { recursive: true });
+    const manifestPath = join(resourcePath, "manifest.json");
+    await writeFile(manifestPath, JSON.stringify(resource.manifest.toJSON(), null, 2), "utf-8");
+    const contentPath = join(resourcePath, "content.tar.gz");
     const serialized = await this.typeHandler.serialize(resource);
-    await contentArl.deposit(serialized);
+    await writeFile(contentPath, serialized);
   }
-  async resolve(locator) {
+  async get(locator) {
     if (!await this.exists(locator)) {
       throw new RegistryError(`Resource not found: ${locator}`);
     }
-    const manifestUrl = this.buildUrl(locator, "manifest.json");
-    const manifestArl = this.arp.parse(manifestUrl);
-    const manifestResult = await manifestArl.resolve();
-    const manifestData = JSON.parse(manifestResult.content);
+    const resourcePath = this.buildPath(locator);
+    const manifestPath = join(resourcePath, "manifest.json");
+    const manifestContent = await readFile(manifestPath, "utf-8");
+    const manifestData = JSON.parse(manifestContent);
     const manifest = createRXM(manifestData);
-    const contentUrl = this.buildUrl(locator, "content.tar.gz").replace("arp:text:", "arp:binary:");
-    const contentArl = this.arp.parse(contentUrl);
-    const contentResult = await contentArl.resolve();
-    const data = contentResult.content;
-    const rxr = await this.typeHandler.deserialize(data, manifest);
+    const contentPath = join(resourcePath, "content.tar.gz");
+    const data = await readFile(contentPath);
+    return this.typeHandler.deserialize(data, manifest);
+  }
+  async resolve(locator) {
+    const rxr = await this.get(locator);
     return this.typeHandler.resolve(rxr);
   }
   async exists(locator) {
-    const manifestUrl = this.buildUrl(locator, "manifest.json");
-    const manifestArl = this.arp.parse(manifestUrl);
-    return manifestArl.exists();
+    const resourcePath = this.buildPath(locator);
+    const manifestPath = join(resourcePath, "manifest.json");
+    try {
+      await stat(manifestPath);
+      return true;
+    } catch {
+      return false;
+    }
   }
   async delete(locator) {
     if (!await this.exists(locator)) {
       return;
     }
-    const manifestUrl = this.buildUrl(locator, "manifest.json");
-    const manifestArl = this.arp.parse(manifestUrl);
-    await manifestArl.delete();
-    const contentUrl = this.buildUrl(locator, "content.tar.gz").replace("arp:text:", "arp:binary:");
-    const contentArl = this.arp.parse(contentUrl);
-    await contentArl.delete();
+    const resourcePath = this.buildPath(locator);
+    await rm(resourcePath, { recursive: true, force: true });
   }
   async search(options) {
     const { query, limit, offset = 0 } = options ?? {};
-    const baseUrl = `arp:text:file://${this.basePath}`;
-    const baseArl = this.arp.parse(baseUrl);
     let entries;
     try {
-      const result2 = await baseArl.resolve({ recursive: "true" });
-      entries = JSON.parse(result2.content);
+      entries = await this.listRecursive(this.basePath);
     } catch {
       return [];
     }
     const locators = [];
     for (const entry of entries) {
-      if (!entry.endsWith("/manifest.json")) {
+      if (!entry.endsWith("manifest.json")) {
         continue;
       }
-      const rxl = this.parseEntryToRXL(entry);
+      const relativePath = entry.slice(this.basePath.length + 1);
+      const rxl = this.parseEntryToRXL(relativePath);
       if (rxl) {
         locators.push(rxl);
       }
@@ -2042,9 +1574,25 @@ class ARPRegistry {
     }
     return result;
   }
+  async listRecursive(dir) {
+    const results = [];
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          const subEntries = await this.listRecursive(fullPath);
+          results.push(...subEntries);
+        } else {
+          results.push(fullPath);
+        }
+      }
+    } catch {}
+    return results;
+  }
   parseEntryToRXL(entry) {
-    const dirPath = entry.replace(/\/manifest\.json$/, "");
-    const parts = dirPath.split("/");
+    const dirPath = entry.replace(/[/\\]manifest\.json$/, "");
+    const parts = dirPath.split(/[/\\]/);
     if (parts.length < 3) {
       return null;
     }
@@ -2078,14 +1626,105 @@ class ARPRegistry {
     }
   }
 }
+// src/RemoteRegistry.ts
+class RemoteRegistry {
+  endpoint;
+  typeHandler;
+  constructor(config) {
+    this.endpoint = config.endpoint.replace(/\/$/, "");
+    this.typeHandler = TypeHandlerChain.create();
+  }
+  supportType(type) {
+    this.typeHandler.register(type);
+  }
+  async publish(_resource) {
+    throw new RegistryError("Remote registry publish not implemented yet");
+  }
+  async link(_resource) {
+    throw new RegistryError("Cannot link to remote registry - use local registry for linking");
+  }
+  async get(locator) {
+    const manifestUrl = `${this.endpoint}/resource?locator=${encodeURIComponent(locator)}`;
+    const manifestResponse = await fetch(manifestUrl);
+    if (!manifestResponse.ok) {
+      if (manifestResponse.status === 404) {
+        throw new RegistryError(`Resource not found: ${locator}`);
+      }
+      throw new RegistryError(`Failed to fetch resource: ${manifestResponse.statusText}`);
+    }
+    const manifestData = await manifestResponse.json();
+    const manifest = createRXM(manifestData);
+    const contentUrl = `${this.endpoint}/content?locator=${encodeURIComponent(locator)}`;
+    const contentResponse = await fetch(contentUrl);
+    if (!contentResponse.ok) {
+      throw new RegistryError(`Failed to fetch content: ${contentResponse.statusText}`);
+    }
+    const contentBuffer = Buffer.from(await contentResponse.arrayBuffer());
+    return this.typeHandler.deserialize(contentBuffer, manifest);
+  }
+  async resolve(locator) {
+    const rxr = await this.get(locator);
+    return this.typeHandler.resolve(rxr);
+  }
+  async exists(locator) {
+    const url = `${this.endpoint}/exists?locator=${encodeURIComponent(locator)}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      return false;
+    }
+    const data = await response.json();
+    return data.exists === true;
+  }
+  async delete(_locator) {
+    throw new RegistryError("Cannot delete from remote registry - use local registry for deletion");
+  }
+  async search(options) {
+    const params = new URLSearchParams;
+    if (options?.query)
+      params.set("query", options.query);
+    if (options?.limit !== undefined)
+      params.set("limit", String(options.limit));
+    if (options?.offset !== undefined)
+      params.set("offset", String(options.offset));
+    const url = `${this.endpoint}/search?${params.toString()}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new RegistryError(`Search failed: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return (data.results || []).map((locator) => parseRXL(locator));
+  }
+}
+async function discoverRegistry(domain) {
+  const wellKnownUrl = `https://${domain}/.well-known/resourcex`;
+  try {
+    const response = await fetch(wellKnownUrl);
+    if (!response.ok) {
+      throw new RegistryError(`Well-known discovery failed for ${domain}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.registry;
+  } catch (error) {
+    if (error instanceof RegistryError) {
+      throw error;
+    }
+    throw new RegistryError(`Failed to discover registry for ${domain}: ${error.message}`);
+  }
+}
 // src/createRegistry.ts
 function createRegistry(config) {
-  return new ARPRegistry(config);
+  if (isRemoteConfig(config)) {
+    return new RemoteRegistry(config);
+  }
+  return new LocalRegistry(config);
 }
 export {
+  isRemoteConfig,
+  discoverRegistry,
   createRegistry,
+  RemoteRegistry,
   RegistryError,
-  ARPRegistry
+  LocalRegistry
 };
 
-//# debugId=36E7744ADCB7821664756E2164756E21
+//# debugId=E606A28A0E6E3E5464756E2164756E21