space-data-module-sdk 0.8.4 → 0.8.5

package/src/manifest/legacyToPlg.js

@@ -7,21 +7,20 @@
  * continue to work while the embedded manifest bytes switch to the
  * canonical spacedatastandards.org PLG schema.
  *
- * Lossy mappings:
+ * Compatibility mappings:
  *   - plugin_family → plugin_type (best-effort; families without a PLG
  *     counterpart fall back to `Analysis`).
- *   - methods[].input_ports/output_ports → EntryFunction.input_schemas /
- *     output_schema (first accepted type per port).
- *   - drain_policy, max_batch, port cardinalities, timers, protocols,
- *     invoke_surfaces, runtime_targets, build_artifacts are dropped;
- *     these are runtime-host concerns that live out-of-band under PLG.
- *   - schemas_used → required_schemas (type name only).
- *   - capabilities[] preserved; each entry becomes a
- *     PluginCapability {name, required}. (The "scope" on legacy entries is
- *     folded into the capability name as `kind#scope` if present.)
+ *   - methods[].input_ports/output_ports are preserved as PLG METHODS and
+ *     summarized into EntryFunction.input_schemas/output_schema for older
+ *     consumers.
+ *   - schemas_used are preserved as PLG SCHEMAS_USED and summarized into
+ *     required_schemas by type name.
+ *   - capabilities[] are preserved both as simple PluginCapability metadata
+ *     and as richer PLGHostCapability records for host/runtime gating.
  */
 
 import { CapabilityKind } from "../generated/orbpro/manifest/capability-kind.js";
+import { PluginFamily } from "../generated/orbpro/manifest/plugin-family.js";
 
 const FAMILY_TO_PLUGIN_TYPE = Object.freeze({
   sensor: "sensor",
@@ -39,10 +38,14 @@ const FAMILY_TO_PLUGIN_TYPE = Object.freeze({
 });
 
 function normalizePluginTypeFromFamily(family) {
-  if (typeof family !== "string") {
+  let key;
+  if (typeof family === "number" && typeof PluginFamily[family] === "string") {
+    key = PluginFamily[family].toLowerCase();
+  } else if (typeof family === "string") {
+    key = family.trim().toLowerCase().replace(/-/g, "_");
+  } else {
     return "analysis";
   }
-  const key = family.trim().toLowerCase().replace(/-/g, "_");
   return FAMILY_TO_PLUGIN_TYPE[key] ?? "analysis";
 }
 
@@ -72,7 +75,12 @@ function firstTypeName(port) {
         return entry;
       }
       if (entry && typeof entry === "object") {
-        const name = entry.name ?? entry.typeName ?? entry.type_name;
+        const name =
+          entry.schemaName ??
+          entry.schema_name ??
+          entry.name ??
+          entry.typeName ??
+          entry.type_name;
         if (typeof name === "string" && name.length > 0) {
           return name;
         }
@@ -135,6 +143,37 @@ function toPluginCapability(capability) {
   return { name, version, required };
 }
 
+function toHostCapability(capability) {
+  if (typeof capability === "string") {
+    return { capability, required: true };
+  }
+  if (!capability || typeof capability !== "object") {
+    return null;
+  }
+  const kind =
+    normalizeCapabilityName(capability.capability) ??
+    normalizeCapabilityName(capability.kind) ??
+    normalizeCapabilityName(capability.name);
+  if (!kind) {
+    return null;
+  }
+  const scope =
+    typeof capability.scope === "string" && capability.scope.trim().length > 0
+      ? capability.scope.trim()
+      : undefined;
+  const description =
+    typeof capability.description === "string" &&
+    capability.description.trim().length > 0
+      ? capability.description.trim()
+      : undefined;
+  return {
+    capability: kind,
+    ...(scope ? { scope } : {}),
+    required: capability.required !== false,
+    ...(description ? { description } : {}),
+  };
+}
+
 function toRequiredSchemas(schemasUsed) {
   if (!Array.isArray(schemasUsed)) {
     return [];
@@ -144,7 +183,12 @@ function toRequiredSchemas(schemasUsed) {
     if (typeof entry === "string" && entry.length > 0) {
       names.push(entry);
     } else if (entry && typeof entry === "object") {
-      const name = entry.name ?? entry.typeName ?? entry.type_name;
+      const name =
+        entry.schemaName ??
+        entry.schema_name ??
+        entry.name ??
+        entry.typeName ??
+        entry.type_name;
       if (typeof name === "string" && name.length > 0) {
         names.push(name);
       }
@@ -154,6 +198,23 @@ function toRequiredSchemas(schemasUsed) {
   return Array.from(new Set(names));
 }
 
+function collectEntrySchemas(entryFunctions) {
+  const names = [];
+  for (const entry of Array.isArray(entryFunctions) ? entryFunctions : []) {
+    for (const name of Array.isArray(entry?.inputSchemas)
+      ? entry.inputSchemas
+      : []) {
+      if (typeof name === "string" && name.length > 0) {
+        names.push(name);
+      }
+    }
+    if (typeof entry?.outputSchema === "string" && entry.outputSchema.length > 0) {
+      names.push(entry.outputSchema);
+    }
+  }
+  return names;
+}
+
 /**
  * Convert a legacy PluginManifest-shaped input to a PLG-shaped object.
  * If the input already looks like a PLG object (has entryFunctions OR
@@ -167,12 +228,17 @@ export function legacyManifestToPlg(input = {}) {
 
   const hasLegacyMethods = Array.isArray(input.methods);
   const hasPlgEntries = Array.isArray(input.entryFunctions);
+  const schemasUsed = Array.isArray(input.schemasUsed)
+    ? input.schemasUsed
+    : Array.isArray(input.schemas_used)
+      ? input.schemas_used
+      : [];
 
   const pluginType = hasLegacyMethods
     ? normalizePluginTypeFromFamily(input.pluginFamily ?? input.plugin_family)
-    : typeof input.pluginType === "string"
+    : typeof input.pluginType === "string" || typeof input.pluginType === "number"
       ? input.pluginType
-      : typeof input.plugin_type === "string"
+      : typeof input.plugin_type === "string" || typeof input.plugin_type === "number"
         ? input.plugin_type
         : normalizePluginTypeFromFamily(input.pluginFamily);
 
@@ -184,11 +250,66 @@ export function legacyManifestToPlg(input = {}) {
 
   const requiredSchemas = Array.isArray(input.requiredSchemas)
     ? input.requiredSchemas
-    : toRequiredSchemas(input.schemasUsed ?? input.schemas_used);
+    : Array.isArray(input.required_schemas)
+      ? input.required_schemas
+    : Array.from(
+        new Set([
+          ...toRequiredSchemas(schemasUsed),
+          ...collectEntrySchemas(entryFunctions),
+        ]),
+      );
 
   const capabilities = Array.isArray(input.capabilities)
     ? input.capabilities.map((cap) => toPluginCapability(cap)).filter(Boolean)
     : [];
+  const hostCapabilitySource = Array.isArray(input.hostCapabilities)
+    ? input.hostCapabilities
+    : Array.isArray(input.host_capabilities)
+      ? input.host_capabilities
+      : Array.isArray(input.capabilities)
+        ? input.capabilities
+        : [];
+  const hostCapabilities = hostCapabilitySource
+    .map((cap) => toHostCapability(cap))
+    .filter(Boolean);
+  const runtimeTargets = Array.isArray(input.runtimeTargets)
+    ? input.runtimeTargets
+    : Array.isArray(input.runtime_targets)
+      ? input.runtime_targets
+      : [];
+  const minPermissions = Array.isArray(input.minPermissions)
+    ? input.minPermissions
+    : Array.isArray(input.min_permissions)
+      ? input.min_permissions
+      : runtimeTargets;
+  const flowNodes = Array.isArray(input.flowNodes)
+    ? input.flowNodes
+    : Array.isArray(input.flow_nodes)
+      ? input.flow_nodes
+      : Array.isArray(input.FLOW_NODES)
+        ? input.FLOW_NODES
+        : [];
+  const flowEdges = Array.isArray(input.flowEdges)
+    ? input.flowEdges
+    : Array.isArray(input.flow_edges)
+      ? input.flow_edges
+      : Array.isArray(input.FLOW_EDGES)
+        ? input.FLOW_EDGES
+        : [];
+  const flowTriggers = Array.isArray(input.flowTriggers)
+    ? input.flowTriggers
+    : Array.isArray(input.flow_triggers)
+      ? input.flow_triggers
+      : Array.isArray(input.FLOW_TRIGGERS)
+        ? input.FLOW_TRIGGERS
+        : [];
+  const flowTriggerBindings = Array.isArray(input.flowTriggerBindings)
+    ? input.flowTriggerBindings
+    : Array.isArray(input.flow_trigger_bindings)
+      ? input.flow_trigger_bindings
+      : Array.isArray(input.FLOW_TRIGGER_BINDINGS)
+        ? input.FLOW_TRIGGER_BINDINGS
+        : [];
 
   return {
     pluginId: input.pluginId ?? input.plugin_id ?? input.PLUGIN_ID,
@@ -212,23 +333,41 @@ export function legacyManifestToPlg(input = {}) {
     wasmSize: input.wasmSize ?? input.wasm_size,
     wasmCid: input.wasmCid ?? input.wasm_cid,
     entryFunctions,
+    methods: Array.isArray(input.methods) ? input.methods : [],
+    invokeSurfaces: Array.isArray(input.invokeSurfaces)
+      ? input.invokeSurfaces
+      : Array.isArray(input.invoke_surfaces)
+        ? input.invoke_surfaces
+        : [],
+    runtimeTargets,
     requiredSchemas,
+    schemasUsed,
     dependencies: Array.isArray(input.dependencies) ? input.dependencies : [],
     capabilities,
+    hostCapabilities,
+    timers: Array.isArray(input.timers) ? input.timers : [],
+    protocols: Array.isArray(input.protocols) ? input.protocols : [],
+    buildArtifacts: Array.isArray(input.buildArtifacts)
+      ? input.buildArtifacts
+      : Array.isArray(input.build_artifacts)
+        ? input.build_artifacts
+        : [],
+    flowNodes,
+    flowEdges,
+    flowTriggers,
+    flowTriggerBindings,
     providerPeerId: input.providerPeerId ?? input.provider_peer_id,
     providerEpmCid: input.providerEpmCid ?? input.provider_epm_cid,
     encrypted: input.encrypted === true,
     requiredScope: input.requiredScope ?? input.required_scope,
     keyId: input.keyId ?? input.key_id,
-    allowedDomains: Array.isArray(input.allowedDomains)
-      ? input.allowedDomains
-      : [],
-    maxGrantTimeoutMs: input.maxGrantTimeoutMs ?? input.max_grant_timeout_ms,
-    minPermissions: Array.isArray(input.minPermissions)
-      ? input.minPermissions
-      : Array.isArray(input.runtimeTargets)
-        ? input.runtimeTargets
+    allowedXpubs: Array.isArray(input.allowedXpubs)
+      ? input.allowedXpubs
+      : Array.isArray(input.allowed_xpubs)
+        ? input.allowed_xpubs
         : [],
+    maxGrantTimeoutMs: input.maxGrantTimeoutMs ?? input.max_grant_timeout_ms,
+    minPermissions,
     createdAt: input.createdAt ?? input.created_at,
     updatedAt: input.updatedAt ?? input.updated_at,
     documentationUrl: input.documentationUrl ?? input.documentation_url,

package/src/manifest/normalize.js

@@ -63,6 +63,7 @@ const capabilityKindByName = Object.freeze({
   storage_adapter: CapabilityKind.STORAGE_ADAPTER,
   storage_query: CapabilityKind.STORAGE_QUERY,
   storage_write: CapabilityKind.STORAGE_WRITE,
+  storage_ingest: CapabilityKind.STORAGE_INGEST,
   wallet_sign: CapabilityKind.WALLET_SIGN,
   ipfs: CapabilityKind.IPFS,
   crypto_hash: CapabilityKind.CRYPTO_HASH,