sdn-flow 0.2.0

package/src/designer/requirements.js

@@ -0,0 +1,184 @@
+import {
+  ExternalInterfaceDirection,
+  ExternalInterfaceKind,
+  TriggerKind,
+  normalizeManifest,
+  normalizeProgram,
+} from "../runtime/index.js";
+
+function canonicalInterfaceKey(externalInterface) {
+  return [
+    externalInterface.kind,
+    externalInterface.direction,
+    externalInterface.capability,
+    externalInterface.resource,
+    externalInterface.protocolId,
+    externalInterface.topic,
+    externalInterface.path,
+  ]
+    .map((value) => value ?? "")
+    .join("::");
+}
+
+function mergeInterfaces(targetMap, interfaces, owner) {
+  for (const externalInterface of interfaces) {
+    const key = canonicalInterfaceKey(externalInterface);
+    const existing = targetMap.get(key);
+    if (existing) {
+      existing.owners.add(owner);
+      continue;
+    }
+    targetMap.set(key, {
+      ...externalInterface,
+      owners: new Set([owner]),
+    });
+  }
+}
+
+function triggerToExternalInterface(trigger) {
+  switch (trigger.kind) {
+    case TriggerKind.TIMER:
+      return {
+        interfaceId: trigger.triggerId,
+        kind: ExternalInterfaceKind.TIMER,
+        direction: ExternalInterfaceDirection.INPUT,
+        capability: "timers",
+        resource: trigger.source ?? trigger.triggerId,
+        description: trigger.description,
+        required: true,
+        acceptedTypes: trigger.acceptedTypes,
+        properties: {
+          defaultIntervalMs: trigger.defaultIntervalMs,
+        },
+      };
+    case TriggerKind.PUBSUB_SUBSCRIPTION:
+      return {
+        interfaceId: trigger.triggerId,
+        kind: ExternalInterfaceKind.PUBSUB,
+        direction: ExternalInterfaceDirection.INPUT,
+        capability: "pubsub",
+        resource: trigger.source ?? trigger.triggerId,
+        topic: trigger.source ?? null,
+        description: trigger.description,
+        required: true,
+        acceptedTypes: trigger.acceptedTypes,
+        properties: {},
+      };
+    case TriggerKind.PROTOCOL_REQUEST:
+      return {
+        interfaceId: trigger.triggerId,
+        kind: ExternalInterfaceKind.PROTOCOL,
+        direction: ExternalInterfaceDirection.INPUT,
+        capability: "protocol_handle",
+        resource: trigger.protocolId ?? trigger.source ?? trigger.triggerId,
+        protocolId: trigger.protocolId,
+        description: trigger.description,
+        required: true,
+        acceptedTypes: trigger.acceptedTypes,
+        properties: {},
+      };
+    case TriggerKind.HTTP_REQUEST:
+      return {
+        interfaceId: trigger.triggerId,
+        kind: ExternalInterfaceKind.HTTP,
+        direction: ExternalInterfaceDirection.INPUT,
+        capability: "http",
+        resource: trigger.source ?? trigger.triggerId,
+        path: trigger.source ?? null,
+        description: trigger.description,
+        required: true,
+        acceptedTypes: trigger.acceptedTypes,
+        properties: {},
+      };
+    default:
+      return null;
+  }
+}
+
+export function summarizeProgramRequirements({
+  program,
+  registry = null,
+  manifests = [],
+} = {}) {
+  const normalizedProgram = normalizeProgram(program);
+  const interfaceMap = new Map();
+  const capabilities = new Set();
+  const pluginSummaries = [];
+  const seenPluginIds = new Set();
+
+  mergeInterfaces(interfaceMap, normalizedProgram.externalInterfaces, "program");
+  for (const trigger of normalizedProgram.triggers) {
+    const externalInterface = triggerToExternalInterface(trigger);
+    if (externalInterface) {
+      mergeInterfaces(interfaceMap, [externalInterface], `trigger:${trigger.triggerId}`);
+    }
+  }
+
+  const availableManifests = new Map();
+  for (const manifest of manifests) {
+    const normalizedManifest = normalizeManifest(manifest);
+    availableManifests.set(normalizedManifest.pluginId, normalizedManifest);
+  }
+  if (registry && typeof registry.listPlugins === "function") {
+    for (const pluginRecord of registry.listPlugins()) {
+      availableManifests.set(pluginRecord.pluginId, pluginRecord.manifest);
+    }
+  }
+
+  for (const pluginId of normalizedProgram.requiredPlugins) {
+    seenPluginIds.add(pluginId);
+  }
+  for (const node of normalizedProgram.nodes) {
+    seenPluginIds.add(node.pluginId);
+  }
+
+  for (const pluginId of seenPluginIds) {
+    const manifest = availableManifests.get(pluginId);
+    if (!manifest) {
+      pluginSummaries.push({
+        pluginId,
+        resolved: false,
+        capabilities: [],
+        externalInterfaces: [],
+      });
+      continue;
+    }
+    pluginSummaries.push({
+      pluginId,
+      resolved: true,
+      capabilities: manifest.capabilities,
+      externalInterfaces: manifest.externalInterfaces,
+    });
+    for (const capability of manifest.capabilities) {
+      capabilities.add(capability);
+    }
+    mergeInterfaces(interfaceMap, manifest.externalInterfaces, `plugin:${pluginId}`);
+  }
+
+  for (const dependency of normalizedProgram.artifactDependencies) {
+    for (const capability of dependency.requiredCapabilities) {
+      capabilities.add(capability);
+    }
+  }
+
+  return {
+    programId: normalizedProgram.programId,
+    capabilities: Array.from(capabilities).sort(),
+    externalInterfaces: Array.from(interfaceMap.values())
+      .map((externalInterface) => ({
+        ...externalInterface,
+        owners: Array.from(externalInterface.owners).sort(),
+      }))
+      .sort((left, right) =>
+        `${left.kind}:${left.direction}:${left.resource ?? ""}`.localeCompare(
+          `${right.kind}:${right.direction}:${right.resource ?? ""}`,
+        ),
+      ),
+    artifactDependencies: normalizedProgram.artifactDependencies,
+    plugins: pluginSummaries.sort((left, right) =>
+      left.pluginId.localeCompare(right.pluginId),
+    ),
+  };
+}
+
+export default summarizeProgramRequirements;

package/src/generated/runtimeAbiLayouts.js

@@ -0,0 +1,544 @@
+// Auto-generated from schemas/FlowRuntimeAbi.fbs - DO NOT EDIT.
+
+export const FlowFrameDescriptorLayout = Object.freeze({
+  schema: "sdn.flow.abi.FlowFrameDescriptor",
+  schemaPath: "schemas/FlowRuntimeAbi.fbs",
+  size: 48,
+  alignment: 8,
+  ingressIndexOffset: 0,
+  typeDescriptorIndexOffset: 4,
+  portIdPointerOffset: 8,
+  alignmentOffset: 12,
+  offsetOffset: 16,
+  sizeOffset: 20,
+  streamIdOffset: 24,
+  sequenceOffset: 28,
+  traceTokenOffset: 32,
+  endOfStreamOffset: 40,
+  occupiedOffset: 41,
+  fields: Object.freeze({
+    ingressIndex: Object.freeze({
+      schemaField: "ingress_index",
+      offset: 0,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    typeDescriptorIndex: Object.freeze({
+      schemaField: "type_descriptor_index",
+      offset: 4,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    portIdPointer: Object.freeze({
+      schemaField: "port_id_pointer",
+      offset: 8,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    alignment: Object.freeze({
+      schemaField: "alignment",
+      offset: 12,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    offset: Object.freeze({
+      schemaField: "offset",
+      offset: 16,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    size: Object.freeze({
+      schemaField: "size",
+      offset: 20,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    streamId: Object.freeze({
+      schemaField: "stream_id",
+      offset: 24,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    sequence: Object.freeze({
+      schemaField: "sequence",
+      offset: 28,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    traceToken: Object.freeze({
+      schemaField: "trace_token",
+      offset: 32,
+      size: 8,
+      alignment: 8,
+      scalarType: "uint64",
+    }),
+    endOfStream: Object.freeze({
+      schemaField: "end_of_stream",
+      offset: 40,
+      size: 1,
+      alignment: 1,
+      scalarType: "bool",
+    }),
+    occupied: Object.freeze({
+      schemaField: "occupied",
+      offset: 41,
+      size: 1,
+      alignment: 1,
+      scalarType: "bool",
+    }),
+  }),
+});
+
+export const FlowInvocationDescriptorLayout = Object.freeze({
+  schema: "sdn.flow.abi.FlowInvocationDescriptor",
+  schemaPath: "schemas/FlowRuntimeAbi.fbs",
+  size: 24,
+  alignment: 4,
+  nodeIndexOffset: 0,
+  dispatchDescriptorIndexOffset: 4,
+  pluginIdPointerOffset: 8,
+  methodIdPointerOffset: 12,
+  framesPointerOffset: 16,
+  frameCountOffset: 20,
+  fields: Object.freeze({
+    nodeIndex: Object.freeze({
+      schemaField: "node_index",
+      offset: 0,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    dispatchDescriptorIndex: Object.freeze({
+      schemaField: "dispatch_descriptor_index",
+      offset: 4,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    pluginIdPointer: Object.freeze({
+      schemaField: "plugin_id_pointer",
+      offset: 8,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    methodIdPointer: Object.freeze({
+      schemaField: "method_id_pointer",
+      offset: 12,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    framesPointer: Object.freeze({
+      schemaField: "frames_pointer",
+      offset: 16,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    frameCount: Object.freeze({
+      schemaField: "frame_count",
+      offset: 20,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+  }),
+});
+
+export const FlowNodeDispatchDescriptorLayout = Object.freeze({
+  schema: "sdn.flow.abi.FlowNodeDispatchDescriptor",
+  schemaPath: "schemas/FlowRuntimeAbi.fbs",
+  size: 60,
+  alignment: 4,
+  nodeIdPointerOffset: 0,
+  nodeIndexOffset: 4,
+  dependencyIdPointerOffset: 8,
+  dependencyIndexOffset: 12,
+  pluginIdPointerOffset: 16,
+  methodIdPointerOffset: 20,
+  dispatchModelPointerOffset: 24,
+  entrypointPointerOffset: 28,
+  manifestBytesSymbolPointerOffset: 32,
+  manifestSizeSymbolPointerOffset: 36,
+  initSymbolPointerOffset: 40,
+  destroySymbolPointerOffset: 44,
+  mallocSymbolPointerOffset: 48,
+  freeSymbolPointerOffset: 52,
+  streamInvokeSymbolPointerOffset: 56,
+  fields: Object.freeze({
+    nodeIdPointer: Object.freeze({
+      schemaField: "node_id_pointer",
+      offset: 0,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    nodeIndex: Object.freeze({
+      schemaField: "node_index",
+      offset: 4,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    dependencyIdPointer: Object.freeze({
+      schemaField: "dependency_id_pointer",
+      offset: 8,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    dependencyIndex: Object.freeze({
+      schemaField: "dependency_index",
+      offset: 12,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    pluginIdPointer: Object.freeze({
+      schemaField: "plugin_id_pointer",
+      offset: 16,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    methodIdPointer: Object.freeze({
+      schemaField: "method_id_pointer",
+      offset: 20,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    dispatchModelPointer: Object.freeze({
+      schemaField: "dispatch_model_pointer",
+      offset: 24,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    entrypointPointer: Object.freeze({
+      schemaField: "entrypoint_pointer",
+      offset: 28,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    manifestBytesSymbolPointer: Object.freeze({
+      schemaField: "manifest_bytes_symbol_pointer",
+      offset: 32,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    manifestSizeSymbolPointer: Object.freeze({
+      schemaField: "manifest_size_symbol_pointer",
+      offset: 36,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    initSymbolPointer: Object.freeze({
+      schemaField: "init_symbol_pointer",
+      offset: 40,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    destroySymbolPointer: Object.freeze({
+      schemaField: "destroy_symbol_pointer",
+      offset: 44,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    mallocSymbolPointer: Object.freeze({
+      schemaField: "malloc_symbol_pointer",
+      offset: 48,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    freeSymbolPointer: Object.freeze({
+      schemaField: "free_symbol_pointer",
+      offset: 52,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    streamInvokeSymbolPointer: Object.freeze({
+      schemaField: "stream_invoke_symbol_pointer",
+      offset: 56,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+  }),
+});
+
+export const SignedArtifactDependencyDescriptorLayout = Object.freeze({
+  schema: "sdn.flow.abi.SignedArtifactDependencyDescriptor",
+  schemaPath: "schemas/FlowRuntimeAbi.fbs",
+  size: 72,
+  alignment: 4,
+  dependencyIdPointerOffset: 0,
+  pluginIdPointerOffset: 4,
+  versionPointerOffset: 8,
+  sha256PointerOffset: 12,
+  signaturePointerOffset: 16,
+  signerPublicKeyPointerOffset: 20,
+  entrypointPointerOffset: 24,
+  manifestBytesSymbolPointerOffset: 28,
+  manifestSizeSymbolPointerOffset: 32,
+  initSymbolPointerOffset: 36,
+  destroySymbolPointerOffset: 40,
+  mallocSymbolPointerOffset: 44,
+  freeSymbolPointerOffset: 48,
+  streamInvokeSymbolPointerOffset: 52,
+  wasmBytesPointerOffset: 56,
+  wasmSizeOffset: 60,
+  manifestBytesPointerOffset: 64,
+  manifestSizeOffset: 68,
+  fields: Object.freeze({
+    dependencyIdPointer: Object.freeze({
+      schemaField: "dependency_id_pointer",
+      offset: 0,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    pluginIdPointer: Object.freeze({
+      schemaField: "plugin_id_pointer",
+      offset: 4,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    versionPointer: Object.freeze({
+      schemaField: "version_pointer",
+      offset: 8,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    sha256Pointer: Object.freeze({
+      schemaField: "sha256_pointer",
+      offset: 12,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    signaturePointer: Object.freeze({
+      schemaField: "signature_pointer",
+      offset: 16,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    signerPublicKeyPointer: Object.freeze({
+      schemaField: "signer_public_key_pointer",
+      offset: 20,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    entrypointPointer: Object.freeze({
+      schemaField: "entrypoint_pointer",
+      offset: 24,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    manifestBytesSymbolPointer: Object.freeze({
+      schemaField: "manifest_bytes_symbol_pointer",
+      offset: 28,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    manifestSizeSymbolPointer: Object.freeze({
+      schemaField: "manifest_size_symbol_pointer",
+      offset: 32,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    initSymbolPointer: Object.freeze({
+      schemaField: "init_symbol_pointer",
+      offset: 36,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    destroySymbolPointer: Object.freeze({
+      schemaField: "destroy_symbol_pointer",
+      offset: 40,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    mallocSymbolPointer: Object.freeze({
+      schemaField: "malloc_symbol_pointer",
+      offset: 44,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    freeSymbolPointer: Object.freeze({
+      schemaField: "free_symbol_pointer",
+      offset: 48,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    streamInvokeSymbolPointer: Object.freeze({
+      schemaField: "stream_invoke_symbol_pointer",
+      offset: 52,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    wasmBytesPointer: Object.freeze({
+      schemaField: "wasm_bytes_pointer",
+      offset: 56,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    wasmSize: Object.freeze({
+      schemaField: "wasm_size",
+      offset: 60,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    manifestBytesPointer: Object.freeze({
+      schemaField: "manifest_bytes_pointer",
+      offset: 64,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    manifestSize: Object.freeze({
+      schemaField: "manifest_size",
+      offset: 68,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+  }),
+});
+
+export const FlowIngressRuntimeStateLayout = Object.freeze({
+  schema: "sdn.flow.abi.FlowIngressRuntimeState",
+  schemaPath: "schemas/FlowRuntimeAbi.fbs",
+  size: 24,
+  alignment: 8,
+  totalReceivedOffset: 0,
+  totalDroppedOffset: 8,
+  queuedFramesOffset: 16,
+  fields: Object.freeze({
+    totalReceived: Object.freeze({
+      schemaField: "total_received",
+      offset: 0,
+      size: 8,
+      alignment: 8,
+      scalarType: "uint64",
+    }),
+    totalDropped: Object.freeze({
+      schemaField: "total_dropped",
+      offset: 8,
+      size: 8,
+      alignment: 8,
+      scalarType: "uint64",
+    }),
+    queuedFrames: Object.freeze({
+      schemaField: "queued_frames",
+      offset: 16,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+  }),
+});
+
+export const FlowNodeRuntimeStateLayout = Object.freeze({
+  schema: "sdn.flow.abi.FlowNodeRuntimeState",
+  schemaPath: "schemas/FlowRuntimeAbi.fbs",
+  size: 32,
+  alignment: 8,
+  invocationCountOffset: 0,
+  consumedFramesOffset: 8,
+  queuedFramesOffset: 16,
+  backlogRemainingOffset: 20,
+  lastStatusOffset: 24,
+  readyOffset: 28,
+  yieldedOffset: 29,
+  fields: Object.freeze({
+    invocationCount: Object.freeze({
+      schemaField: "invocation_count",
+      offset: 0,
+      size: 8,
+      alignment: 8,
+      scalarType: "uint64",
+    }),
+    consumedFrames: Object.freeze({
+      schemaField: "consumed_frames",
+      offset: 8,
+      size: 8,
+      alignment: 8,
+      scalarType: "uint64",
+    }),
+    queuedFrames: Object.freeze({
+      schemaField: "queued_frames",
+      offset: 16,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    backlogRemaining: Object.freeze({
+      schemaField: "backlog_remaining",
+      offset: 20,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    lastStatus: Object.freeze({
+      schemaField: "last_status",
+      offset: 24,
+      size: 4,
+      alignment: 4,
+      scalarType: "uint32",
+    }),
+    ready: Object.freeze({
+      schemaField: "ready",
+      offset: 28,
+      size: 1,
+      alignment: 1,
+      scalarType: "bool",
+    }),
+    yielded: Object.freeze({
+      schemaField: "yielded",
+      offset: 29,
+      size: 1,
+      alignment: 1,
+      scalarType: "bool",
+    }),
+  }),
+});
+
+export const RuntimeAbiLayouts = Object.freeze({
+  FlowFrameDescriptor: FlowFrameDescriptorLayout,
+  FlowInvocationDescriptor: FlowInvocationDescriptorLayout,
+  FlowNodeDispatchDescriptor: FlowNodeDispatchDescriptorLayout,
+  SignedArtifactDependencyDescriptor: SignedArtifactDependencyDescriptorLayout,
+  FlowIngressRuntimeState: FlowIngressRuntimeStateLayout,
+  FlowNodeRuntimeState: FlowNodeRuntimeStateLayout,
+});