Joe's Friction Log (Archived)

[Mearman]

Thoughts, notes and ponderings

[Mearman]

While working on OpenAlex boards, I wanted to reuse the spread code node.

• First, I tried refactoring it into a separate file and using a TS import to pull it in.
• Then I tried serializing that node and calling it with invoke.
• My most recent attempt was to wrap the spread code node in its own board and using it via an invoke, though that didn't work either.

related:

• create abstracted OpenAlex query board #1160
• extract OpenAlex single query board for use in tool worker #1149

[Mearman]

@dglazkov, are any of these methods the "correct" one? Could you point me to a working example?

[Mearman]

noticed an issue with controlling flow of the board when a node accepts both known and unknown inputs.

• see: when a node receives specific properties from one node and * properties from another node a race condition is caused #1166

[Mearman]

came across .as({}), not entirely sure of the purpose?

breadboard/packages/breadboard-web/src/boards/accumulating-context.ts

Line 43 in c4f887b

parameters.as({}).to(input);

[Mearman]

@dglazkov I'm still curious about this one?

[dglazkov]

This one is the "control" wire. It passes no data over it, just control from one node to another.
In the old syntax, it was the "->".

[Mearman]

Excellent, that was what I surmised. I need to play around with this more explicitly in my looping boards.

[Mearman]

• discovered schema default property is of type string, so doesn't align with the type property  #1164
• related to:
  • [FR] add examples property to schema type #1162
  • [FR] constrain type property of schema type #1163

[Mearman]

• related to Add generic type handling #1217
  In terms of generics, this is a minimal example of a function that would make full use of polymorphic node types

function doSomething<T extends Record<string, I>, I>({
  inputKey = "input",
  outputKey = "output",
  ...rest
}: {
  inputKey?: string;
  outputKey?: string;
} & T): Record<string, I> {
  // Ensure inputKey exists in the input object to prevent runtime errors
  if (!(inputKey in rest)) {
    throw new Error(`Input key "${inputKey}" not found in input object.`);
  }

  return {
    [outputKey]: rest[inputKey],
  };
}

// Example usage:
const result = doSomething({
  input: "value",
  outputKey: "out",
});
console.log(result);

[Mearman]

Not really friction but in writing the array and object utility nodes, I had a thought that about exporting a code node that also wraps the function, so it can be encoded in the board and used with only the core kit. e.g.

export function unshift<T>({
  array,
  elements,
}: {
  array: T[];
  elements: T[];
}): {
  array: T[];
} {
  array.unshift(...elements);
  return { array };
}

export const unshiftNodeType: MonomorphicDefinition<
  {
    array: {
      type: AdvancedBreadboardType<unknown[]>;
    };
    elements: {
      type: AdvancedBreadboardType<unknown[]>;
    };
  },
  {
    array: {
      type: AdvancedBreadboardType<unknown[]>;
    };
  }
> = defineNodeType({
  inputs: {
    array: {
      type: array("unknown"),
    },
    elements: {
      type: array("unknown"),
    },
  },
  outputs: {
    array: {
      type: array("unknown"),
    },
  },
  invoke: unshift,
});

also providing this

export const unshiftCode: Lambda<
  {
    array: unknown[];
    elements: unknown[];
  },
  {
    array: unknown[];
  }
> = code(({ array, elements }) => unshift({ array, elements }));

[Mearman]

Something that occurred to me yesterday. it's not always clear when a schema is being used for the in or out ports of a node

[dglazkov]

all ports have schemas, whether inferred or specified. Only input and output node allow specifying their ports using a special schema port.

[dglazkov]

Does that clarify anything 😆

[Mearman]

It does. I think my confusion was because of the various points the types can be specified for nodes that are not inputs or outputs