@resourcexjs/core 2.5.4 → 2.5.6

package/dist/index.js

@@ -35,7 +35,7 @@ class DefinitionError extends ResourceXError {
     this.name = "DefinitionError";
   }
 }
-// src/primitives/define.ts
+// src/model/define.ts
 function define(input) {
   if (input === null || typeof input !== "object") {
     throw new DefinitionError("definition must be an object");
@@ -66,7 +66,7 @@ function define(input) {
   };
   return rxd;
 }
-// src/primitives/manifest.ts
+// src/model/manifest.ts
 function manifest(rxd) {
   return {
     registry: rxd.registry,
@@ -76,7 +76,7 @@ function manifest(rxd) {
     tag: rxd.tag ?? "latest"
   };
 }
-// src/primitives/archive.ts
+// src/model/archive.ts
 import { gzip } from "node:zlib";
 import { promisify } from "node:util";
 
@@ -1057,7 +1057,7 @@ async function unpackTar(archive, options = {}) {
   return results;
 }
 
-// src/primitives/archive.ts
+// src/model/archive.ts
 var gzipAsync = promisify(gzip);
 
 class RXAImpl {
@@ -1089,7 +1089,7 @@ async function archive(files) {
   const gzipBuffer = await gzipAsync(Buffer.from(tarBuffer));
   return new RXAImpl(gzipBuffer);
 }
-// src/primitives/locate.ts
+// src/model/locate.ts
 function locate(rxm) {
   return {
     registry: rxm.registry,
@@ -1098,7 +1098,7 @@ function locate(rxm) {
     tag: rxm.tag
   };
 }
-// src/primitives/resource.ts
+// src/model/resource.ts
 function resource(rxm, rxa) {
   const rxl = locate(rxm);
   return {
@@ -1107,7 +1107,7 @@ function resource(rxm, rxa) {
     archive: rxa
   };
 }
-// src/primitives/extract.ts
+// src/model/extract.ts
 import { gunzip } from "node:zlib";
 import { promisify as promisify2 } from "node:util";
 var gunzipAsync = promisify2(gunzip);
@@ -1123,7 +1123,7 @@ async function extract(rxa) {
   }
   return files;
 }
-// src/primitives/format.ts
+// src/model/format.ts
 function format(rxl) {
   let result = "";
   if (rxl.registry) {
@@ -1138,7 +1138,7 @@ function format(rxl) {
   }
   return result;
 }
-// src/primitives/parse.ts
+// src/model/parse.ts
 function looksLikeRegistry(str) {
   if (str.includes(":") && !str.includes("/")) {
     return true;
@@ -1207,7 +1207,7 @@ function parse(locator) {
     tag
   };
 }
-// src/primitives/wrap.ts
+// src/model/wrap.ts
 class RXAImpl2 {
   _buffer;
   constructor(buffer) {
@@ -1229,21 +1229,689 @@ class RXAImpl2 {
 function wrap(buffer) {
   return new RXAImpl2(buffer);
 }
+// src/type/bundler.ts
+import { readFile } from "node:fs/promises";
+import { resolve, isAbsolute } from "node:path";
+async function bundleResourceType(sourcePath, basePath) {
+  const fullPath = isAbsolute(sourcePath) ? sourcePath : resolve(basePath ?? process.cwd(), sourcePath);
+  const source = await readFile(fullPath, "utf-8");
+  const result = await Bun.build({
+    stdin: {
+      contents: source,
+      resolveDir: resolve(fullPath, ".."),
+      loader: "ts"
+    },
+    target: "bun",
+    format: "esm",
+    minify: false
+  });
+  if (!result.success) {
+    const errors = result.logs.map((log) => log.message).join(`
+`);
+    throw new Error(`Failed to bundle ${sourcePath}: ${errors}`);
+  }
+  const bundledCode = await result.outputs[0].text();
+  const tempModule = await import(fullPath);
+  const typeSource = tempModule.default;
+  if (!typeSource.name) {
+    throw new Error(`Resource type at ${sourcePath} must have a name`);
+  }
+  if (typeof typeSource.resolve !== "function") {
+    throw new Error(`Resource type at ${sourcePath} must have a resolve function`);
+  }
+  return {
+    name: typeSource.name,
+    aliases: typeSource.aliases,
+    description: typeSource.description ?? "",
+    schema: typeSource.schema,
+    code: bundledCode
+  };
+}
+// src/type/errors.ts
+class ResourceTypeError extends ResourceXError {
+  constructor(message) {
+    super(message);
+    this.name = "ResourceTypeError";
+  }
+}
+// src/type/builtinTypes.ts
+var textType = {
+  name: "text",
+  aliases: ["txt", "plaintext"],
+  description: "Plain text content",
+  code: `// @resolver: text_type_default
+// src/builtins/text.type.ts
+var text_type_default = {
+  name: "text",
+  aliases: ["txt", "plaintext"],
+  description: "Plain text content",
+  async resolve(ctx) {
+    const content = ctx.files["content"];
+    return new TextDecoder().decode(content);
+  }
+};`
+};
+var jsonType = {
+  name: "json",
+  aliases: ["config", "manifest"],
+  description: "JSON content",
+  code: `// @resolver: json_type_default
+// src/builtins/json.type.ts
+var json_type_default = {
+  name: "json",
+  aliases: ["config", "manifest"],
+  description: "JSON content",
+  async resolve(ctx) {
+    const content = ctx.files["content"];
+    return JSON.parse(new TextDecoder().decode(content));
+  }
+};`
+};
+var binaryType = {
+  name: "binary",
+  aliases: ["bin", "blob", "raw"],
+  description: "Binary content",
+  code: `// @resolver: binary_type_default
+// src/builtins/binary.type.ts
+var binary_type_default = {
+  name: "binary",
+  aliases: ["bin", "blob", "raw"],
+  description: "Binary content",
+  async resolve(ctx) {
+    return ctx.files["content"];
+  }
+};`
+};
+var builtinTypes = [textType, jsonType, binaryType];
+
+// src/type/TypeHandlerChain.ts
+class TypeHandlerChain {
+  handlers = new Map;
+  constructor() {
+    for (const type of builtinTypes) {
+      this.registerInternal(type);
+    }
+  }
+  static create() {
+    return new TypeHandlerChain;
+  }
+  registerInternal(type) {
+    this.handlers.set(type.name, type);
+    if (type.aliases) {
+      for (const alias of type.aliases) {
+        this.handlers.set(alias, type);
+      }
+    }
+  }
+  register(type) {
+    if (this.handlers.has(type.name)) {
+      throw new ResourceTypeError(`Type '${type.name}' is already registered`);
+    }
+    this.handlers.set(type.name, type);
+    if (type.aliases) {
+      for (const alias of type.aliases) {
+        if (this.handlers.has(alias)) {
+          throw new ResourceTypeError(`Alias '${alias}' conflicts with existing type or alias`);
+        }
+        this.handlers.set(alias, type);
+      }
+    }
+  }
+  canHandle(typeName) {
+    return this.handlers.has(typeName);
+  }
+  getHandler(typeName) {
+    const handler = this.handlers.get(typeName);
+    if (!handler) {
+      throw new ResourceTypeError(`Unsupported resource type: ${typeName}`);
+    }
+    return handler;
+  }
+  getHandlerOrUndefined(typeName) {
+    return this.handlers.get(typeName);
+  }
+  getSupportedTypes() {
+    return Array.from(this.handlers.keys());
+  }
+  clear() {
+    this.handlers.clear();
+  }
+}
+// src/loader/FolderLoader.ts
+import { join, relative } from "node:path";
+import { stat, readFile as readFile2, readdir } from "node:fs/promises";
+class FolderLoader {
+  async canLoad(source) {
+    try {
+      const stats = await stat(source);
+      if (!stats.isDirectory()) {
+        return false;
+      }
+      const manifestPath = join(source, "resource.json");
+      const manifestStats = await stat(manifestPath);
+      return manifestStats.isFile();
+    } catch {
+      return false;
+    }
+  }
+  async load(folderPath) {
+    const resourceJsonPath = join(folderPath, "resource.json");
+    let resourceJson;
+    try {
+      resourceJson = await readFile2(resourceJsonPath, "utf-8");
+    } catch (error) {
+      throw new ResourceXError(`Failed to read resource.json: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let json;
+    try {
+      json = JSON.parse(resourceJson);
+    } catch (error) {
+      throw new ResourceXError(`Invalid JSON in resource.json: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const rxd = define(json);
+    const files = await this.readFolderFiles(folderPath);
+    if (Object.keys(files).length === 0) {
+      throw new ResourceXError("No content files found in resource folder");
+    }
+    const rxm = manifest(rxd);
+    const rxa = await archive(files);
+    return resource(rxm, rxa);
+  }
+  async readFolderFiles(folderPath, basePath = folderPath) {
+    const files = {};
+    const entries = await readdir(folderPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(folderPath, entry.name);
+      const relativePath = relative(basePath, fullPath);
+      if (relativePath === "resource.json") {
+        continue;
+      }
+      if (entry.isFile()) {
+        files[relativePath] = await readFile2(fullPath);
+      } else if (entry.isDirectory()) {
+        const subFiles = await this.readFolderFiles(fullPath, basePath);
+        Object.assign(files, subFiles);
+      }
+    }
+    return files;
+  }
+}
+// src/loader/loadResource.ts
+async function loadResource(source, config) {
+  const loader = config?.loader ?? new FolderLoader;
+  const canLoad = await loader.canLoad(source);
+  if (!canLoad) {
+    throw new ResourceXError(`Cannot load resource from: ${source}`);
+  }
+  return loader.load(source);
+}
+// src/registry/errors.ts
+class RegistryError extends ResourceXError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RegistryError";
+  }
+}
+
+// src/registry/registries/CASRegistry.ts
+class CASRegistry {
+  rxaStore;
+  rxmStore;
+  constructor(rxaStore, rxmStore) {
+    this.rxaStore = rxaStore;
+    this.rxmStore = rxmStore;
+  }
+  async get(rxl) {
+    const tag = rxl.tag ?? "latest";
+    const storedRxm = await this.rxmStore.get(rxl.name, tag, rxl.registry);
+    if (!storedRxm) {
+      throw new RegistryError(`Resource not found: ${format(rxl)}`);
+    }
+    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)
+    };
+    const rxa = await archive(files);
+    return resource(rxm, rxa);
+  }
+  async put(rxr) {
+    const files = await extract(rxr.archive);
+    const fileDigests = {};
+    for (const [filename, content] of Object.entries(files)) {
+      const digest = await this.rxaStore.put(content);
+      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,
+      files: fileDigests,
+      createdAt: new Date,
+      updatedAt: new Date
+    };
+    await this.rxmStore.put(storedRxm);
+  }
+  async has(rxl) {
+    const tag = rxl.tag ?? "latest";
+    return this.rxmStore.has(rxl.name, tag, rxl.registry);
+  }
+  async remove(rxl) {
+    const tag = rxl.tag ?? "latest";
+    await this.rxmStore.delete(rxl.name, tag, rxl.registry);
+  }
+  async list(options) {
+    const { query, limit, offset = 0 } = options ?? {};
+    const manifests = await this.rxmStore.search({
+      query,
+      limit,
+      offset
+    });
+    return manifests.map((m) => ({
+      registry: m.registry,
+      path: m.path,
+      name: m.name,
+      tag: m.tag
+    }));
+  }
+  async clearCache(registry) {
+    if (registry) {
+      await this.rxmStore.deleteByRegistry(registry);
+    } else {
+      const cached = await this.rxmStore.search({ registry: undefined });
+      for (const m of cached) {
+        if (m.registry) {
+          await this.rxmStore.delete(m.name, m.tag, m.registry);
+        }
+      }
+    }
+  }
+  async gc() {
+    const referenced = new Set;
+    const allManifests = await this.rxmStore.search({});
+    for (const m of allManifests) {
+      for (const digest of Object.values(m.files)) {
+        referenced.add(digest);
+      }
+    }
+    let deleted = 0;
+    const allDigests = await this.rxaStore.list();
+    for (const digest of allDigests) {
+      if (!referenced.has(digest)) {
+        await this.rxaStore.delete(digest);
+        deleted++;
+      }
+    }
+    return deleted;
+  }
+  async hasBlob(digest) {
+    return this.rxaStore.has(digest);
+  }
+  async getBlob(digest) {
+    return this.rxaStore.get(digest);
+  }
+  async putBlob(data) {
+    return this.rxaStore.put(data);
+  }
+}
+// src/registry/registries/LinkedRegistry.ts
+import { join as join2, resolve as resolvePath } from "node:path";
+import { symlink, lstat, readlink, rm, mkdir, readdir as readdir2 } from "node:fs/promises";
+class LinkedRegistry {
+  basePath;
+  constructor(basePath) {
+    this.basePath = basePath;
+  }
+  buildLinkPath(rxl) {
+    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, rxl.name, tag);
+  }
+  async isSymlink(path) {
+    try {
+      const stats = await lstat(path);
+      return stats.isSymbolicLink();
+    } catch {
+      return false;
+    }
+  }
+  async get(rxl) {
+    const linkPath = this.buildLinkPath(rxl);
+    if (!await this.isSymlink(linkPath)) {
+      throw new RegistryError(`Linked resource not found: ${format(rxl)}`);
+    }
+    const targetPath = await readlink(linkPath);
+    return loadResource(targetPath);
+  }
+  async put(_rxr) {
+    throw new RegistryError("LinkedRegistry does not support put(). Use link() instead.");
+  }
+  async has(rxl) {
+    const linkPath = this.buildLinkPath(rxl);
+    return this.isSymlink(linkPath);
+  }
+  async remove(rxl) {
+    const linkPath = this.buildLinkPath(rxl);
+    if (await this.isSymlink(linkPath)) {
+      await rm(linkPath);
+    }
+  }
+  async list(options) {
+    const { query, limit, offset = 0 } = options ?? {};
+    const locators = [];
+    try {
+      await this.scanSymlinks(this.basePath, "", locators);
+    } catch {
+      return [];
+    }
+    let filtered = locators;
+    if (query) {
+      const lowerQuery = query.toLowerCase();
+      filtered = locators.filter((rxl) => {
+        const searchText = `${rxl.registry ?? ""} ${rxl.path ?? ""} ${rxl.name}`.toLowerCase();
+        return searchText.includes(lowerQuery);
+      });
+    }
+    let result = filtered.slice(offset);
+    if (limit !== undefined) {
+      result = result.slice(0, limit);
+    }
+    return result;
+  }
+  async link(devPath) {
+    const rxr = await loadResource(devPath);
+    const linkPath = this.buildLinkPath(rxr.locator);
+    try {
+      const stats = await lstat(linkPath);
+      if (stats.isSymbolicLink() || stats.isDirectory()) {
+        await rm(linkPath, { recursive: true });
+      }
+    } catch {}
+    const parentPath = join2(linkPath, "..");
+    await mkdir(parentPath, { recursive: true });
+    const absolutePath = resolvePath(devPath);
+    await symlink(absolutePath, linkPath);
+    return rxr.locator;
+  }
+  async unlink(rxl) {
+    return this.remove(rxl);
+  }
+  async scanSymlinks(dirPath, relativePath, locators) {
+    let entries;
+    try {
+      entries = await readdir2(dirPath);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join2(dirPath, entry);
+      const relPath = relativePath ? `${relativePath}/${entry}` : entry;
+      try {
+        const stats = await lstat(fullPath);
+        if (stats.isSymbolicLink()) {
+          const rxl = this.parsePathToRXL(relPath);
+          if (rxl) {
+            locators.push(rxl);
+          }
+        } else if (stats.isDirectory()) {
+          await this.scanSymlinks(fullPath, relPath, locators);
+        }
+      } catch {}
+    }
+  }
+  parsePathToRXL(relPath) {
+    const parts = relPath.split("/");
+    if (parts.length < 3) {
+      return null;
+    }
+    const tag = parts.pop();
+    const name = parts.pop();
+    const registry = parts.shift();
+    const path = parts.length > 0 ? parts.join("/") : undefined;
+    let locatorStr = registry;
+    if (path)
+      locatorStr += `/${path}`;
+    locatorStr += `/${name}`;
+    if (tag !== "latest")
+      locatorStr += `:${tag}`;
+    try {
+      return parse(locatorStr);
+    } catch {
+      return null;
+    }
+  }
+}
+// src/registry/store/digest.ts
+import { createHash } from "node:crypto";
+function computeDigest(data) {
+  const hash = createHash("sha256").update(data).digest("hex");
+  return `sha256:${hash}`;
+}
+function isValidDigest(digest) {
+  return /^sha256:[a-f0-9]{64}$/.test(digest);
+}
+// src/registry/store/MemoryRXAStore.ts
+class MemoryRXAStore {
+  blobs = new Map;
+  async get(digest) {
+    const blob = this.blobs.get(digest);
+    if (!blob) {
+      throw new RegistryError(`Blob not found: ${digest}`);
+    }
+    return blob;
+  }
+  async put(data) {
+    const digest = computeDigest(data);
+    if (!this.blobs.has(digest)) {
+      this.blobs.set(digest, data);
+    }
+    return digest;
+  }
+  async has(digest) {
+    return this.blobs.has(digest);
+  }
+  async delete(digest) {
+    this.blobs.delete(digest);
+  }
+  async list() {
+    return Array.from(this.blobs.keys());
+  }
+  clear() {
+    this.blobs.clear();
+  }
+}
+// src/registry/store/MemoryRXMStore.ts
+class MemoryRXMStore {
+  manifests = new Map;
+  buildKey(name, tag, registry) {
+    return registry ? `${registry}/${name}:${tag}` : `${name}:${tag}`;
+  }
+  async get(name, tag, registry) {
+    const key = this.buildKey(name, tag, registry);
+    return this.manifests.get(key) ?? null;
+  }
+  async put(manifest2) {
+    const key = this.buildKey(manifest2.name, manifest2.tag, manifest2.registry);
+    this.manifests.set(key, {
+      ...manifest2,
+      updatedAt: new Date
+    });
+  }
+  async has(name, tag, registry) {
+    const key = this.buildKey(name, tag, registry);
+    return this.manifests.has(key);
+  }
+  async delete(name, tag, registry) {
+    const key = this.buildKey(name, tag, registry);
+    this.manifests.delete(key);
+  }
+  async listTags(name, registry) {
+    const tags = [];
+    for (const m of this.manifests.values()) {
+      if (m.name === name && m.registry === registry) {
+        tags.push(m.tag);
+      }
+    }
+    return tags;
+  }
+  async listNames(registry, query) {
+    const names = new Set;
+    for (const m of this.manifests.values()) {
+      if (registry !== undefined && m.registry !== registry)
+        continue;
+      if (query && !m.name.toLowerCase().includes(query.toLowerCase()))
+        continue;
+      names.add(m.name);
+    }
+    return Array.from(names);
+  }
+  async search(options) {
+    const { registry, query, limit, offset = 0 } = options ?? {};
+    let results = Array.from(this.manifests.values());
+    if (registry !== undefined) {
+      if (registry === null) {
+        results = results.filter((m) => !m.registry);
+      } else {
+        results = results.filter((m) => m.registry === registry);
+      }
+    }
+    if (query) {
+      const lowerQuery = query.toLowerCase();
+      results = results.filter((m) => m.name.toLowerCase().includes(lowerQuery));
+    }
+    results = results.slice(offset);
+    if (limit !== undefined) {
+      results = results.slice(0, limit);
+    }
+    return results;
+  }
+  async deleteByRegistry(registry) {
+    for (const [key, m] of this.manifests.entries()) {
+      if (m.registry === registry) {
+        this.manifests.delete(key);
+      }
+    }
+  }
+  clear() {
+    this.manifests.clear();
+  }
+}
+// src/registry/discovery.ts
+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();
+    if (!data.registries || !Array.isArray(data.registries) || data.registries.length === 0) {
+      throw new RegistryError(`Invalid well-known response for ${domain}: missing or empty registries`);
+    }
+    return {
+      domain,
+      registries: data.registries
+    };
+  } catch (error) {
+    if (error instanceof RegistryError) {
+      throw error;
+    }
+    throw new RegistryError(`Failed to discover registry for ${domain}: ${error.message}`);
+  }
+}
+// src/registry/middleware/RegistryMiddleware.ts
+class RegistryMiddleware {
+  inner;
+  constructor(inner) {
+    this.inner = inner;
+  }
+  get(rxl) {
+    return this.inner.get(rxl);
+  }
+  put(rxr) {
+    return this.inner.put(rxr);
+  }
+  has(rxl) {
+    return this.inner.has(rxl);
+  }
+  remove(rxl) {
+    return this.inner.remove(rxl);
+  }
+  list(options) {
+    return this.inner.list(options);
+  }
+}
+// src/registry/middleware/DomainValidation.ts
+class RegistryValidation extends RegistryMiddleware {
+  trustedRegistry;
+  constructor(inner, trustedRegistry) {
+    super(inner);
+    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}"`);
+    }
+  }
+  async get(rxl) {
+    const rxr = await this.inner.get(rxl);
+    this.validateRegistry(rxr);
+    return rxr;
+  }
+}
+function withRegistryValidation(registry, trustedRegistry) {
+  return new RegistryValidation(registry, trustedRegistry);
+}
+var DomainValidation = RegistryValidation;
+var withDomainValidation = withRegistryValidation;
 export {
   wrap,
+  withDomainValidation,
+  textType,
   resource,
   parse,
   manifest,
   locate,
+  loadResource,
+  jsonType,
+  isValidDigest,
   format,
   extract,
+  discoverRegistry,
   define,
+  computeDigest,
+  bundleResourceType,
+  builtinTypes,
+  binaryType,
   archive,
+  TypeHandlerChain,
   ResourceXError,
+  ResourceTypeError,
+  RegistryMiddleware,
+  RegistryError,
+  MemoryRXMStore,
+  MemoryRXAStore,
   ManifestError,
   LocatorError,
+  LinkedRegistry,
+  FolderLoader,
+  DomainValidation,
   DefinitionError,
-  ContentError
+  ContentError,
+  CASRegistry
 };
 
-//# debugId=E36D0778C816F02964756E2164756E21
+//# debugId=E62BE3673C4E081E64756E2164756E21