@jxsuite/parser 0.35.0 → 1.0.0

package/dist/content-loader.js

@@ -0,0 +1,271 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/content-loader.ts
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { basename, extname, resolve } from "node:path";
+function loadJSONEntries(filePath) {
+  const raw = JSON.parse(readFileSync(filePath, "utf8"));
+  if (Array.isArray(raw)) {
+    return raw.map((item, i) => ({
+      body: null,
+      data: item,
+      id: item.id ?? `${basename(filePath, ".json")}-${i}`
+    }));
+  }
+  const rawObj = raw;
+  return [
+    {
+      body: null,
+      data: rawObj,
+      id: rawObj.id ?? basename(filePath, ".json")
+    }
+  ];
+}
+function discoverJSONFiles(resolvedSource) {
+  if (extname(resolvedSource)) {
+    return existsSync(resolvedSource) ? [resolvedSource] : [];
+  }
+  try {
+    return readdirSync(resolvedSource, { recursive: true }).filter((f) => String(f).endsWith(".json")).map((f) => resolve(resolvedSource, String(f)));
+  } catch {
+    return [];
+  }
+}
+function loadContentConfig(projectRoot, projectConfig) {
+  const contentDir = resolve(projectRoot, "content");
+  const config = { content: projectConfig?.content ?? {} };
+  return { config, contentDir };
+}
+async function loadContentSection(section, root, formats) {
+  const contentTypes = new Map;
+  for (const [name, contentTypeDef] of Object.entries(section)) {
+    const entries = await loadContentType(name, contentTypeDef, root, formats);
+    contentTypes.set(name, entries);
+  }
+  return contentTypes;
+}
+function getContentTypeElements(projectRoot, contentTypeName, projectConfig) {
+  const { config } = loadContentConfig(projectRoot, projectConfig);
+  const def = config.content[contentTypeName];
+  return def?.$elements;
+}
+async function loadContentType(name, contentTypeDef, projectRoot, registry) {
+  const { source } = contentTypeDef;
+  if (!source) {
+    return [];
+  }
+  const schema = contentTypeDef.schema;
+  const directiveOptions = contentTypeDef.$elements?.length ? {
+    allowedNames: contentTypeDef.$elements.filter((e) => typeof e === "string" || typeof e === "object" && e?.$ref).map((e) => typeof e === "string" ? e : e.$ref)
+  } : undefined;
+  const formatName = contentTypeDef.format;
+  let entry;
+  if (formatName && formatName !== "json") {
+    entry = registry.byName(formatName);
+    if (!entry) {
+      throw new Error(`Content type "${name}": format "${formatName}" is not a registered format class. ` + `Enable an extension providing it in project.json "extensions", e.g. "@jxsuite/parser".`);
+    }
+  }
+  if (source.startsWith("http://") || source.startsWith("https://")) {
+    if (!entry) {
+      throw new Error(`Content type "${name}": remote sources require an explicit "format" naming a ` + `format class with "remote": true (e.g. "Csv").`);
+    }
+    if (!entry.remote) {
+      throw new Error(`Content type "${name}": format "${entry.name}" does not support remote sources ` + `(its format block lacks "remote": true).`);
+    }
+    try {
+      const entries2 = await entry.call("load", source, {
+        directiveOptions,
+        schema
+      });
+      if (schema) {
+        validateEntries(entries2, schema, name);
+      }
+      return entries2;
+    } catch (error) {
+      console.warn(`Content type "${name}": ${errorMessage(error)}`);
+      return [];
+    }
+  }
+  const resolvedSource = resolve(projectRoot, source).split("\\").join("/");
+  const ext = extname(source).toLowerCase();
+  if (formatName === "json" || !entry && ext === ".json") {
+    const files2 = discoverJSONFiles(resolvedSource);
+    const entries2 = [];
+    for (const filePath of files2) {
+      entries2.push(...loadJSONEntries(filePath));
+    }
+    if (schema) {
+      validateEntries(entries2, schema, name);
+    }
+    return entries2;
+  }
+  if (!entry && ext) {
+    entry = registry.byExtension(ext, "load");
+  }
+  if (!entry) {
+    throw unknownFormatError(source, ext || `content type "${name}" (directory sources need an explicit "format")`);
+  }
+  const files = entry.capabilities.discover ? await entry.call("discover", source, {
+    baseDir: projectRoot
+  }) : [resolvedSource];
+  const entries = [];
+  for (const filePath of files) {
+    entries.push(...await entry.call("load", filePath, {
+      directiveOptions,
+      schema
+    }));
+  }
+  if (schema) {
+    validateEntries(entries, schema, name);
+  }
+  return entries;
+}
+function unknownFormatError(path, ext) {
+  return new Error(`No format class registered for "${ext}" (${path}). ` + `Enable an extension providing this format in project.json "extensions", ` + `e.g. "@jxsuite/parser".`);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function validateEntries(entries, schema, contentTypeName) {
+  const required = schema.required ?? [];
+  const properties = schema.properties ?? {};
+  for (const entry of entries) {
+    for (const field of required) {
+      if (!(field in entry.data) || entry.data[field] == null) {
+        console.warn(`Content validation: "${contentTypeName}/${entry.id}" missing required field "${field}"`);
+      }
+    }
+    for (const [field, def] of Object.entries(properties)) {
+      const value = entry.data[field];
+      if (value == null) {
+        continue;
+      }
+      if (def.type === "string" && typeof value !== "string") {
+        console.warn(`Content validation: "${contentTypeName}/${entry.id}" field "${field}" expected string, got ${typeof value}`);
+      } else if (def.type === "number" && typeof value !== "number") {
+        console.warn(`Content validation: "${contentTypeName}/${entry.id}" field "${field}" expected number, got ${typeof value}`);
+      } else if (def.type === "boolean" && typeof value !== "boolean") {
+        console.warn(`Content validation: "${contentTypeName}/${entry.id}" field "${field}" expected boolean, got ${typeof value}`);
+      } else if (def.type === "array" && !Array.isArray(value)) {
+        console.warn(`Content validation: "${contentTypeName}/${entry.id}" field "${field}" expected array, got ${typeof value}`);
+      }
+    }
+  }
+}
+var CONTENT_REF_PREFIX = "#/content/";
+function refTargetName(ref) {
+  if (!ref?.startsWith(CONTENT_REF_PREFIX)) {
+    return;
+  }
+  return ref.slice(CONTENT_REF_PREFIX.length);
+}
+function resolveContentTypeRefs(contentTypes, section) {
+  for (const [name, contentTypeDef] of Object.entries(section)) {
+    const schema = contentTypeDef.schema;
+    if (!schema?.properties) {
+      continue;
+    }
+    const entries = contentTypes.get(name);
+    if (!entries) {
+      continue;
+    }
+    for (const [field, def] of Object.entries(schema.properties)) {
+      const toOne = refTargetName(def.$ref);
+      const toMany = toOne ? undefined : refTargetName(def.items?.$ref);
+      const target = toOne ?? toMany;
+      if (!target) {
+        continue;
+      }
+      const refEntries = contentTypes.get(target);
+      if (!refEntries) {
+        continue;
+      }
+      for (const entry of entries) {
+        const value = entry.data[field];
+        if (toOne && typeof value === "string") {
+          const resolved = refEntries.find((e) => e.id === value);
+          if (resolved) {
+            entry.data[field] = resolved;
+          }
+        } else if (toMany && Array.isArray(value)) {
+          entry.data[field] = value.map((id) => typeof id === "string" ? refEntries.find((e) => e.id === id) ?? id : id);
+        }
+      }
+    }
+  }
+}
+
+class Content {
+  static async projectData(sectionValue, ctx) {
+    const section = sectionValue ?? {};
+    const data = await loadContentSection(section, ctx.root, ctx.registry.formats);
+    resolveContentTypeRefs(data, section);
+    return data;
+  }
+  static async resolvePaths(pathsDef, ctx) {
+    const entries = ctx.data.get(pathsDef.contentType);
+    if (!entries || entries.length === 0) {
+      console.warn(`Warning: $paths references content type "${pathsDef.contentType}" but it has no entries`);
+      return [];
+    }
+    const param = pathsDef.param ?? "slug";
+    const field = pathsDef.field ?? "id";
+    return entries.map((entry) => ({
+      [param]: field === "id" ? entry.id : entry.data[field] ?? entry.id
+    })).filter((p) => p[param]);
+  }
+}
+export {
+  resolveContentTypeRefs,
+  loadContentSection,
+  loadContentConfig,
+  getContentTypeElements,
+  Content
+};

package/dist/content.js

@@ -140,7 +140,7 @@ class ContentCollection {
   }
   resolve() {
     const { contentType, filter, sort, limit, _project } = this.config;
-    const entries = _project?.contentTypes?.get(contentType ?? "");
+    const entries = _project?.content?.get(contentType ?? "");
     if (!entries) {
       return [];
     }
@@ -163,7 +163,7 @@ class ContentEntry {
   }
   resolve() {
     const { contentType, id, field, _project, _document } = this.config;
-    const entries = _project?.contentTypes?.get(contentType ?? "");
+    const entries = _project?.content?.get(contentType ?? "");
     if (!entries) {
       return null;
     }

package/dist/markdown.js

@@ -858,7 +858,7 @@ var init_unified = __esm(() => {
   init_lib3();
 });
 
-// ../schema/src/guards.ts
+// ../../packages/schema/src/guards.ts
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -30939,7 +30939,7 @@ var init_property_information3 = __esm(() => {
   svg6 = merge3([aria3, svg5, xlink3, xmlns3, xml3], "svg");
 });
 
-// src/html-to-jx.ts
+// ../../packages/markup/src/html-to-jx.ts
 function htmlToJx(htmlString) {
   const hast = fromHtml(htmlString, { fragment: true });
   return convertHastChildren(hast.children);

package/dist/serialize.js

@@ -858,7 +858,7 @@ var init_unified = __esm(() => {
   init_lib3();
 });
 
-// ../schema/src/guards.ts
+// ../../packages/schema/src/guards.ts
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -30939,7 +30939,7 @@ var init_property_information3 = __esm(() => {
   svg6 = merge3([aria3, svg5, xlink3, xmlns3, xml3], "svg");
 });
 
-// src/html-to-jx.ts
+// ../../packages/markup/src/html-to-jx.ts
 function htmlToJx(htmlString) {
   const hast = fromHtml(htmlString, { fragment: true });
   return convertHastChildren(hast.children);

package/jx-extension.json

@@ -0,0 +1,17 @@
+{
+  "name": "@jxsuite/parser",
+  "title": "Content & Markdown",
+  "description": "File-based content collections with Markdown and CSV formats",
+  "classes": {
+    "Markdown": "./src/Markdown.class.json",
+    "Csv": "./src/Csv.class.json",
+    "MarkdownCollection": "./src/MarkdownCollection.class.json",
+    "ContentCollection": "./src/ContentCollection.class.json",
+    "ContentEntry": "./src/ContentEntry.class.json",
+    "Content": "./src/Content.class.json"
+  },
+  "schemas": {
+    "project": "./schemas/project.fragment.schema.json",
+    "document": "./schemas/document.fragment.schema.json"
+  }
+}

package/package.json

@@ -1,25 +1,32 @@
 {
   "name": "@jxsuite/parser",
-  "version": "0.35.0",
+  "version": "1.0.0",
   "description": "Jx markdown parser and external class integration",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/jxsuite/jx.git",
-    "directory": "packages/parser"
+    "directory": "extensions/parser"
   },
   "files": [
     "src/",
-    "dist"
+    "dist",
+    "jx-extension.json",
+    "schemas/"
   ],
   "type": "module",
   "exports": {
     ".": "./src/md.ts",
     "./content": "./src/content.ts",
+    "./content-loader": "./src/content-loader.ts",
     "./markdown": "./src/markdown.ts",
     "./md-html": "./src/md-html.ts",
     "./csv": "./src/csv.ts",
     "./serialize": "./src/serialize.ts",
+    "./jx-extension.json": "./jx-extension.json",
+    "./schemas/project.fragment.schema.json": "./schemas/project.fragment.schema.json",
+    "./schemas/document.fragment.schema.json": "./schemas/document.fragment.schema.json",
+    "./Content.class.json": "./src/Content.class.json",
     "./ContentCollection.class.json": "./src/ContentCollection.class.json",
     "./ContentEntry.class.json": "./src/ContentEntry.class.json",
     "./MarkdownCollection.class.json": "./src/MarkdownCollection.class.json",
@@ -33,28 +40,23 @@
     "provenance": true
   },
   "scripts": {
-    "prepare": "bun build src/content.ts src/markdown.ts src/csv.ts src/serialize.ts --outdir=dist --format=esm --target=node",
+    "prepare": "bun build src/content.ts src/content-loader.ts src/markdown.ts src/csv.ts src/serialize.ts --outdir=dist --format=esm --target=node",
     "build": "bun run prepare",
-    "build:metafile": "bun build src/content.ts src/markdown.ts src/csv.ts src/serialize.ts --outdir=dist --format=esm --target=node --metafile=metafile.json",
+    "build:metafile": "bun build src/content.ts src/content-loader.ts src/markdown.ts src/csv.ts src/serialize.ts --outdir=dist --format=esm --target=node --metafile=metafile.json",
     "test": "bun test --isolate",
     "test:coverage": "bun test --isolate --coverage",
     "upgrade": "bunx npm-check-updates -u && bun install"
   },
   "dependencies": {
-    "@jxsuite/schema": "^0.34.0",
+    "@jxsuite/markup": "^0.2.0",
+    "@jxsuite/schema": "^1.0.0",
     "glob": "^13.0.6",
-    "hast-util-from-html": "^2.0.3",
-    "hast-util-whitespace": "^3.0.0",
     "mdast-util-to-string": "^4.0.0",
-    "property-information": "^7.2.0",
-    "rehype-sanitize": "^6.0.0",
-    "rehype-stringify": "^10.0.1",
     "remark-directive": "^4.0.0",
     "remark-frontmatter": "^5.0.0",
     "remark-gfm": "^4.0.1",
     "remark-parse": "^11.0.0",
     "remark-parse-frontmatter": "^1.0.3",
-    "remark-rehype": "^11.1.2",
     "remark-stringify": "^11.0.0",
     "unified": "^11.0.5",
     "unist-util-visit": "^5.1.0",
@@ -62,8 +64,9 @@
   },
   "devDependencies": {
     "@happy-dom/global-registrator": "^20.10.6",
-    "@jxsuite/runtime": "^0.34.1",
-    "@types/hast": "^3.0.4",
-    "@types/mdast": "^4.0.4"
-  }
+    "@jxsuite/runtime": "^1.0.0",
+    "@types/mdast": "^4.0.4",
+    "ajv": "^8.20.0"
+  },
+  "jx": "./jx-extension.json"
 }

package/schemas/document.fragment.schema.json

@@ -0,0 +1,27 @@
+{
+  "$id": "https://jxsuite.com/schema/ext/parser/document/v1",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Parser document fragment",
+  "description": "Document-schema fragment contributed by @jxsuite/parser: the content-type `$paths` source shape unioned into the document paths resource.",
+  "$defs": {
+    "ContentPathsSource": {
+      "description": "Content-type $paths source: expands a dynamic route from the entries of a loaded content type.",
+      "type": "object",
+      "properties": {
+        "contentType": {
+          "description": "Name of the content type (a key of the project.json `content` section).",
+          "type": "string"
+        },
+        "param": {
+          "description": "Route parameter to fill from each entry (default \"slug\").",
+          "type": "string"
+        },
+        "field": {
+          "description": "Entry field providing the parameter value; \"id\" (the default) uses the entry id.",
+          "type": "string"
+        }
+      },
+      "required": ["contentType"]
+    }
+  }
+}

package/schemas/project.fragment.schema.json

@@ -0,0 +1,59 @@
+{
+  "$id": "https://jxsuite.com/schema/ext/parser/project/v1",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Parser project fragment",
+  "description": "Project-schema fragment contributed by @jxsuite/parser: the `content` section declaring file-based content collections.",
+  "type": "object",
+  "properties": {
+    "content": {
+      "description": "File-based content collections. Each key names a content type; entries are loaded from the named source through the format registry.",
+      "type": "object",
+      "additionalProperties": {
+        "description": "Content type definition. Defines the source directory, frontmatter schema, and element dependencies.",
+        "type": "object",
+        "properties": {
+          "$elements": {
+            "description": "Custom elements available in markdown directives for this content type.",
+            "type": "array",
+            "items": {
+              "oneOf": [
+                {
+                  "type": "object",
+                  "properties": { "$ref": { "type": "string" } },
+                  "required": ["$ref"]
+                },
+                { "type": "string" }
+              ]
+            }
+          },
+          "format": {
+            "description": "Name of a format class provided by an enabled extension (e.g. \"Markdown\", \"Csv\"). When omitted, the format is derived from the source file extension via the format registry. \"json\" is the only built-in.",
+            "type": "string"
+          },
+          "schema": {
+            "description": "JSON Schema for validating frontmatter of content type entries.",
+            "type": "object",
+            "properties": {
+              "type": { "const": "object" },
+              "properties": {
+                "description": "Field definitions; values are field schemas from the effective project field union.",
+                "type": "object",
+                "additionalProperties": { "$ref": "https://jxsuite.com/schema/project/fields/v2" }
+              },
+              "required": {
+                "description": "Frontmatter fields every entry must provide.",
+                "type": "array",
+                "items": { "type": "string" }
+              }
+            }
+          },
+          "source": {
+            "description": "Path to the content directory relative to the project root.",
+            "examples": ["./content/blog/", "./content/docs/"],
+            "type": "string"
+          }
+        }
+      }
+    }
+  }
+}

package/src/Content.class.json

@@ -0,0 +1,117 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://jxsuite.com/schemas/Content.class.json",
+  "title": "Content",
+  "description": "Content-collections project section for Jx: loads the project.json `content` section into _project.content and expands content-type $paths into route params",
+  "$prototype": "Class",
+  "extends": "Object",
+  "$implementation": "./content-loader.js",
+
+  "project": {
+    "key": "content",
+    "title": "Content Types",
+    "description": "File-based content collections loaded at build and dev-serve time",
+    "referenceable": true
+  },
+
+  "$studio": {
+    "settings": {
+      "icon": "sp-icon-view-grid",
+      "label": "Content Types",
+      "order": 50,
+      "layout": "map",
+      "entry": {
+        "ui": { "schema": { "control": "schema-builder" } },
+        "newEntry": {
+          "source": "./content/${key}/",
+          "schema": { "type": "object", "properties": {}, "required": [] }
+        }
+      }
+    }
+  },
+
+  "$defs": {
+    "returnTypes": {
+      "SectionData": {
+        "type": "object",
+        "description": "Map of content type name → ContentLoaderEntry[], with relationship references resolved"
+      },
+      "PathEntries": {
+        "type": "array",
+        "description": "Route-param objects, one per content entry: { [param]: value }",
+        "items": { "type": "object" }
+      }
+    },
+
+    "methods": {
+      "projectData": {
+        "role": "projectData",
+        "$prototype": "Function",
+        "access": "public",
+        "scope": "static",
+        "identifier": "projectData",
+        "timing": ["compiler", "server"],
+        "parameters": [
+          {
+            "identifier": "sectionValue",
+            "type": { "type": "object" },
+            "description": "The project.json `content` section value (content type name → definition)"
+          },
+          {
+            "identifier": "ctx",
+            "type": {
+              "type": "object",
+              "properties": {
+                "projectConfig": { "type": "object" },
+                "root": { "type": "string" },
+                "registry": { "type": "object" },
+                "io": { "type": "object" }
+              }
+            },
+            "description": "Host context: { projectConfig, root, registry, io }"
+          }
+        ],
+        "returnType": { "$ref": "#/$defs/returnTypes/SectionData" },
+        "description": "Load every content type in the section through the format registry, resolving relationship references"
+      },
+      "resolvePaths": {
+        "role": "resolvePaths",
+        "$prototype": "Function",
+        "access": "public",
+        "scope": "static",
+        "identifier": "resolvePaths",
+        "discriminator": "contentType",
+        "timing": ["compiler", "server"],
+        "parameters": [
+          {
+            "identifier": "pathsDef",
+            "type": {
+              "type": "object",
+              "properties": {
+                "contentType": { "type": "string" },
+                "param": { "type": "string", "default": "slug" },
+                "field": { "type": "string", "default": "id" }
+              },
+              "required": ["contentType"]
+            },
+            "description": "The $paths value carrying the contentType discriminator"
+          },
+          {
+            "identifier": "ctx",
+            "type": {
+              "type": "object",
+              "properties": {
+                "data": { "type": "object" },
+                "projectConfig": { "type": "object" },
+                "root": { "type": "string" }
+              }
+            },
+            "description": "Host context: { data, projectConfig, root } where data is the projectData result"
+          }
+        ],
+        "returnType": { "$ref": "#/$defs/returnTypes/PathEntries" },
+        "description": "Expand a content-type $paths source into one route-param object per entry (param defaults to \"slug\", field to \"id\")"
+      }
+    }
+  }
+}

package/src/ContentCollection.class.json

@@ -10,7 +10,7 @@
     "parameters": {
       "contentType": {
         "identifier": "contentType",
-        "type": { "type": "string", "enum": { "$ref": "#/$context/contentTypes" } },
+        "type": { "type": "string", "enum": { "$ref": "#/$context/content" } },
         "description": "Content type to query"
       },
       "filter": {
@@ -23,7 +23,7 @@
             "properties": {
               "field": {
                 "type": "string",
-                "enum": { "$ref": "#/$context/contentTypes/{@contentType}/schema/properties" }
+                "enum": { "$ref": "#/$context/content/{@contentType}/schema/properties" }
               },
               "op": {
                 "type": "string",
@@ -57,7 +57,7 @@
             "properties": {
               "field": {
                 "type": "string",
-                "enum": { "$ref": "#/$context/contentTypes/{@contentType}/schema/properties" }
+                "enum": { "$ref": "#/$context/content/{@contentType}/schema/properties" }
               },
               "order": { "type": "string", "enum": ["asc", "desc"], "default": "asc" }
             },

package/src/ContentEntry.class.json

@@ -10,7 +10,7 @@
     "parameters": {
       "contentType": {
         "identifier": "contentType",
-        "type": { "type": "string", "enum": { "$ref": "#/$context/contentTypes" } },
+        "type": { "type": "string", "enum": { "$ref": "#/$context/content" } },
         "description": "Content type to query"
       },
       "id": {