Part 1 of CFC (#1099)

* commit wip for a sanity check

* Added Tarjan's to enabled SCCs if we need.

* Change back to ifc as the schema property.

* Propagate ifc properties through node graphs and from argumentSchema to resultSchema.

* replace FIXME with a tagged TODO

* Remove cfcTest, since it's not useful enough

Author: ubik2

builder/src/module.ts

@@ -9,9 +9,10 @@ import type {
   OpaqueRef,
   toJSON,
 } from "./types.ts";
-import { isModule } from "./types.ts";
+import { isModule, isOpaqueRef } from "./types.ts";
 import { opaqueRef } from "./opaque-ref.ts";
 import {
+  applyArgumentIfcToResult,
   connectInputAndOutputs,
   moduleToJSON,
   traverseValue,
@@ -26,7 +27,12 @@ export function createNodeFactory<T = any, R = any>(
     ...moduleSpec,
     toJSON: () => moduleToJSON(module),
   };
-
+  // A module with ifc classification on its argument schema should have at least
+  // that value on its result schema
+  module.resultSchema = applyArgumentIfcToResult(
+    module.argumentSchema,
+    module.resultSchema,
+  );
   return Object.assign((inputs: Opaque<T>): OpaqueRef<R> => {
     const outputs = opaqueRef<R>();
     const node: NodeRef = { module, inputs, outputs, frame: getTopFrame() };

builder/src/opaque-ref.ts

@@ -50,6 +50,7 @@ export function opaqueRef<T>(
     nodes: new Set<NodeRef>(),
     frame: getTopFrame()!,
     name: undefined as string | undefined,
+    schema: schema,
   };
 
   let unsafe_binding: { recipe: Recipe; path: PropertyKey[] } | undefined;
@@ -81,7 +82,6 @@ export function opaqueRef<T>(
           // For root array elements
           childSchema = schema.items;
         }
-
         return createNestedProxy(
           [...path, key],
           key in methods ? methods[key as keyof OpaqueRefMethods<any>] : store,
@@ -99,14 +99,17 @@ export function opaqueRef<T>(
         if (path.length === 0) store.name = name;
         else throw new Error("Can only set name for root opaque ref");
       },
+      setSchema: (newSchema: JSONSchema) => {
+        // This sets the schema of the nested proxy, but does not alter the parent store's
+        // schema. Our schema variable shadows that one.
+        schema = newSchema;
+      },
       connect: (node: NodeRef) => store.nodes.add(node),
-      export: () => ({
-        cell: top,
-        path,
-        schema,
-        rootSchema,
-        ...store,
-      }),
+      export: () => {
+        // Store's schema won't be the same as ours as a nested proxy
+        // We also don't adjust the defaultValue to be relative to our path
+        return { cell: top, path, rootSchema, ...store, schema };
+      },
       unsafe_bindToRecipeAndPath: (
         recipe: Recipe,
         path: PropertyKey[],

builder/src/recipe.ts

@@ -20,6 +20,8 @@ import {
 } from "./types.ts";
 import { createShadowRef, opaqueRef } from "./opaque-ref.ts";
 import {
+  applyArgumentIfcToResult,
+  applyInputIfcToOutput,
   connectInputAndOutputs,
   createJsonSchema,
   moduleToJSON,
@@ -103,6 +105,8 @@ export function recipe<T, R>(
 
   const outputs = fn!(inputs);
 
+  applyInputIfcToOutput(inputs, outputs);
+
   const result = factoryFromRecipe<T, R>(
     argumentSchema,
     resultSchema,
@@ -174,6 +178,8 @@ function factoryFromRecipe<T, R>(
   inputs = collectCellsAndNodes(inputs);
   outputs = collectCellsAndNodes(outputs);
 
+  applyInputIfcToOutput(inputs, outputs);
+
   // Fill in reasonable names for all cells, where possible:
 
   // First from results
@@ -282,7 +288,8 @@ function factoryFromRecipe<T, R>(
     argumentSchema = argumentSchemaArg;
   }
 
-  const resultSchema: JSONSchema = resultSchemaArg || { type: "object" };
+  const resultSchema =
+    applyArgumentIfcToResult(argumentSchema, resultSchemaArg) || {};
 
   const serializedNodes = Array.from(nodes).map((node) => {
     const module = toJSONWithAliases(node.module, paths) as unknown as Module;

builder/src/types.ts

@@ -35,6 +35,7 @@ export type OpaqueRefMethods<T> = {
   setDefault(value: Opaque<T> | T): void;
   setPreExisting(ref: any): void;
   setName(name: string): void;
+  setSchema(schema: JSONSchema): void;
   connect(node: NodeRef): void;
   export(): {
     cell: OpaqueRef<any>;
@@ -149,6 +150,7 @@ export type JSONSchema = {
   readonly asStream?: boolean;
   readonly anyOf?: readonly JSONSchema[];
   readonly additionalProperties?: Readonly<JSONSchema> | boolean;
+  readonly ifc?: { classification?: string[]; integrity?: string[] }; // temporarily used to assign labels like "confidential"
 };
 
 export { type Mutable };

builder/src/utils.ts

@@ -20,7 +20,13 @@ import {
   unsafe_originalRecipe,
 } from "./types.ts";
 import { getTopFrame } from "./recipe.ts";
-import { type CellLink, isCell, isCellLink, isDoc } from "@commontools/runner";
+import {
+  type CellLink,
+  ContextualFlowControl,
+  isCell,
+  isCellLink,
+  isDoc,
+} from "@commontools/runner";
 
 /**
  * Traverse a value, _not_ entering cells
@@ -347,6 +353,8 @@ export function recipeToJSON(recipe: Recipe) {
 }
 
 export function connectInputAndOutputs(node: NodeRef) {
+  const cfc = new ContextualFlowControl();
+
   function connect(value: any): any {
     if (canBeOpaqueRef(value)) value = makeOpaqueRef(value);
     if (isOpaqueRef(value)) {
@@ -361,4 +369,67 @@ export function connectInputAndOutputs(node: NodeRef) {
 
   node.inputs = traverseValue(node.inputs, connect);
   node.outputs = traverseValue(node.outputs, connect);
+
+  // We will also apply ifc tags from inputs to outputs
+  applyInputIfcToOutput(node.inputs, node.outputs);
+}
+
+export function applyArgumentIfcToResult(
+  argumentSchema?: JSONSchema,
+  resultSchema?: JSONSchema,
+): JSONSchema | undefined {
+  if (argumentSchema !== undefined) {
+    const cfc = new ContextualFlowControl();
+    const joined = cfc.joinSchema(new Set(), argumentSchema);
+    return (joined.size !== 0)
+      ? cfc.schemaWithLub(resultSchema ?? {}, cfc.lub(joined))
+      : resultSchema;
+  }
+  return resultSchema;
+}
+
+// If our inputs had any ifc tags, carry them through to our outputs
+export function applyInputIfcToOutput<T, R>(
+  inputs: Opaque<T>,
+  outputs: Opaque<R>,
+) {
+  const collectedClassifications = new Set<string>();
+  const cfc = new ContextualFlowControl();
+  traverseValue(inputs, (item) => {
+    if (isOpaqueRef(item)) {
+      const { schema: inputSchema } = (item as OpaqueRef<T>).export();
+      if (inputSchema !== undefined) {
+        cfc.joinSchema(collectedClassifications, inputSchema);
+      }
+    }
+  });
+  if (collectedClassifications.size !== 0) {
+    attachCfcToOutputs(outputs, cfc, cfc.lub(collectedClassifications));
+  }
+}
+
+// Attach ifc classification to OpaqueRef objects reachable
+// from the outputs without descending into OpaqueRef objects
+// TODO(@ubik2) Investigate: can we have cycles here?
+function attachCfcToOutputs<T, R>(
+  outputs: Opaque<R>,
+  cfc: ContextualFlowControl,
+  lubClassification: string,
+) {
+  if (isOpaqueRef(outputs)) {
+    const exported = (outputs as OpaqueRef<T>).export();
+    const outputSchema = exported.schema ?? {};
+    // we may have fields in the output schema, so incorporate those
+    const joined = cfc.joinSchema(new Set([lubClassification]), outputSchema);
+    const ifc = (outputSchema.ifc !== undefined) ? { ...outputSchema.ifc } : {};
+    ifc.classification = [cfc.lub(joined)];
+    const cfcSchema: JSONSchema = { ...outputSchema, ifc };
+    (outputs as OpaqueRef<T>).setSchema(cfcSchema);
+    return;
+  } else if (typeof outputs === "object" && outputs !== null) {
+    // Descend into objects and arrays
+    for (const [key, value] of Object.entries(outputs)) {
+      attachCfcToOutputs(value, cfc, lubClassification);
+    }
+  }
 }