@bonsae/nrg 0.5.4 → 0.6.1

package/src/core/server/nodes/io-node.ts

@@ -3,6 +3,7 @@ import type { RED } from "../../server/types";
 import { validator } from "../validator";
 import { Node } from "./node";
 import type {
+  HexColor,
   IONodeContext,
   IONodeContextScope,
   IONodeStatus,
@@ -19,7 +20,7 @@ abstract class IONode<
   TSettings = any,
 > extends Node<TConfig, TCredentials, TSettings> {
   public static readonly align?: "left" | "right";
-  public static readonly color: `#${string}`;
+  public static readonly color: HexColor;
   public static readonly labelStyle?:
     | "node_label"
     | "node_label_italic"

package/src/core/server/nodes/types/factories.ts

@@ -0,0 +1,130 @@
+import { type Static, type TSchema } from "@sinclair/typebox";
+import type { RED } from "../../types";
+import type { IONode } from "../io-node";
+import type { ConfigNode } from "../config-node";
+import type { HexColor } from "./io-node";
+
+type InferOr<T, Fallback> = T extends TSchema ? Static<T> : Fallback;
+
+type InferOutputs<T> = T extends readonly TSchema[]
+  ? { [K in keyof T]: T[K] extends TSchema ? Static<T[K]> : never }
+  : T extends TSchema
+    ? Static<T>
+    : any;
+
+type BoundIONode<
+  TC extends TSchema | undefined,
+  TCr extends TSchema | undefined,
+  TS extends TSchema | undefined,
+  TIn extends TSchema | undefined,
+  TOut extends TSchema | readonly TSchema[] | undefined,
+> = IONode<
+  InferOr<TC, any>,
+  InferOr<TCr, any>,
+  InferOr<TIn, any>,
+  InferOutputs<TOut>,
+  InferOr<TS, any>
+>;
+
+type BoundConfigNode<
+  TC extends TSchema | undefined,
+  TCr extends TSchema | undefined,
+  TS extends TSchema | undefined,
+> = ConfigNode<InferOr<TC, any>, InferOr<TCr, any>, InferOr<TS, any>>;
+
+interface IONodeDefinition<
+  TConfigSchema extends TSchema | undefined = undefined,
+  TCredsSchema extends TSchema | undefined = undefined,
+  TSettingsSchema extends TSchema | undefined = undefined,
+  TInputSchema extends TSchema | undefined = undefined,
+  TOutputsSchema extends TSchema | readonly TSchema[] | undefined = undefined,
+> {
+  type: string;
+  category?: string;
+  color?: HexColor;
+  inputs?: 0 | 1;
+  outputs?: number;
+  paletteLabel?: string;
+  inputLabels?: string | string[];
+  outputLabels?: string | string[];
+  align?: "left" | "right";
+  labelStyle?: string;
+
+  configSchema?: TConfigSchema;
+  credentialsSchema?: TCredsSchema;
+  settingsSchema?: TSettingsSchema;
+  inputSchema?: TInputSchema;
+  outputsSchema?: TOutputsSchema;
+
+  validateInput?: boolean;
+  validateOutput?: boolean;
+
+  registered?(RED: RED): void | Promise<void>;
+  created?(
+    this: BoundIONode<
+      TConfigSchema,
+      TCredsSchema,
+      TSettingsSchema,
+      TInputSchema,
+      TOutputsSchema
+    >,
+  ): void | Promise<void>;
+  closed?(
+    this: BoundIONode<
+      TConfigSchema,
+      TCredsSchema,
+      TSettingsSchema,
+      TInputSchema,
+      TOutputsSchema
+    >,
+    removed?: boolean,
+  ): void | Promise<void>;
+  input?(
+    this: BoundIONode<
+      TConfigSchema,
+      TCredsSchema,
+      TSettingsSchema,
+      TInputSchema,
+      TOutputsSchema
+    >,
+    msg: InferOr<TInputSchema, any>,
+  ): void | Promise<void>;
+}
+
+interface ConfigNodeDefinition<
+  TConfigSchema extends TSchema | undefined = undefined,
+  TCredsSchema extends TSchema | undefined = undefined,
+  TSettingsSchema extends TSchema | undefined = undefined,
+> {
+  type: string;
+
+  configSchema?: TConfigSchema;
+  credentialsSchema?: TCredsSchema;
+  settingsSchema?: TSettingsSchema;
+
+  registered?(RED: RED): void | Promise<void>;
+  created?(
+    this: BoundConfigNode<TConfigSchema, TCredsSchema, TSettingsSchema>,
+  ): void | Promise<void>;
+  closed?(
+    this: BoundConfigNode<TConfigSchema, TCredsSchema, TSettingsSchema>,
+    removed?: boolean,
+  ): void | Promise<void>;
+}
+
+// Return types for factory functions — uses structural typing to avoid
+// referencing internal class paths in declaration emit, while preserving
+// the instance type for NodeRef inference.
+interface NodeClassBase {
+  readonly type: string;
+  readonly category: string;
+  new (...args: any[]): any;
+}
+
+export type {
+  InferOr,
+  InferOutputs,
+  IONodeDefinition,
+  ConfigNodeDefinition,
+  NodeClassBase,
+};

package/src/core/server/nodes/types/index.ts

@@ -1,3 +1,4 @@
 export * from "./node";
 export * from "./io-node";
 export * from "./config-node";
+export type * from "./factories";

package/src/core/server/nodes/types/io-node.ts

@@ -28,7 +28,10 @@ type IONodeContext = {
   global: NodeContextStore;
 };
 
+type HexColor = `#${string}`;
+
 export {
+  HexColor,
   IONodeConfig,
   IONodeContext,
   IONodeContextScope,

package/src/core/server/schemas/types/index.ts

@@ -41,6 +41,7 @@ interface NrgFormOptions {
   icon?: string;
   typedInputTypes?: string[];
   editorLanguage?: string;
+  toggle?: boolean;
 }
 
 declare module "@sinclair/typebox" {

package/src/vite/server/plugins/type-generator.ts

@@ -161,6 +161,139 @@ function getNodeTypeExports(
  * Runtime class values are exposed by `cjsDefaultExportPlugin` dynamically
  * via the `nodes` array on the package function.
  */
+/**
+ * Semantic names for schema properties in both class static properties
+ * and factory definition objects.
+ */
+const SCHEMA_PROP_SEMANTICS: Record<string, string> = {
+  configSchema: "ConfigSchema",
+  credentialsSchema: "CredentialsSchema",
+  inputSchema: "InputSchema",
+  outputsSchema: "OutputsSchema",
+  settingsSchema: "SettingsSchema",
+};
+
+/**
+ * Extract schema references from a node file — works for both class-based
+ * and factory-based (defineIONode/defineConfigNode) patterns.
+ *
+ * Returns an array of { localName, semanticName, importSource } where:
+ * - localName: the identifier used in the file (e.g., "ConfigsSchema")
+ * - semanticName: the semantic slot name (e.g., "ConfigSchema")
+ * - importSource: the relative import path (e.g., "../schemas/my-node")
+ */
+function getSchemaReferences(
+  filePath: string,
+): Array<{ localName: string; semanticName: string; importSource: string }> {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const source = ts.createSourceFile(
+    filePath,
+    content,
+    ts.ScriptTarget.ESNext,
+    true,
+  );
+
+  // Build a map of imported identifiers → their source module
+  const importMap = new Map<string, string>();
+  for (const stmt of source.statements) {
+    if (ts.isImportDeclaration(stmt) && stmt.importClause) {
+      const moduleSpecifier = (stmt.moduleSpecifier as ts.StringLiteral).text;
+      const namedBindings = stmt.importClause.namedBindings;
+      if (namedBindings && ts.isNamedImports(namedBindings)) {
+        for (const el of namedBindings.elements) {
+          importMap.set(el.name.text, moduleSpecifier);
+        }
+      }
+    }
+  }
+
+  // Collect schema property assignments: { propName → identifiers[] }
+  const schemaRefs = new Map<string, string[]>();
+
+  // Extract identifier(s) from an initializer — handles both single identifiers
+  // and array literals like [Output1Schema, Output2Schema].
+  function extractIdentifiers(node: ts.Expression): string[] {
+    if (ts.isIdentifier(node)) return [node.text];
+    if (ts.isArrayLiteralExpression(node)) {
+      return node.elements.filter(ts.isIdentifier).map((el) => el.text);
+    }
+    return [];
+  }
+
+  for (const stmt of source.statements) {
+    // Class-based: static readonly configSchema = ConfigsSchema
+    //              static readonly outputsSchema = [Output1Schema, Output2Schema]
+    if (ts.isClassDeclaration(stmt)) {
+      for (const member of stmt.members) {
+        if (
+          ts.isPropertyDeclaration(member) &&
+          ts.isIdentifier(member.name) &&
+          member.name.text in SCHEMA_PROP_SEMANTICS &&
+          member.initializer
+        ) {
+          const ids = extractIdentifiers(member.initializer);
+          if (ids.length > 0) {
+            schemaRefs.set(member.name.text, ids);
+          }
+        }
+      }
+    }
+
+    // Factory-based: export default defineIONode({ configSchema: X, ... })
+    if (
+      ts.isExportAssignment(stmt) &&
+      stmt.expression &&
+      ts.isCallExpression(stmt.expression)
+    ) {
+      const callee = stmt.expression.expression;
+      if (
+        ts.isIdentifier(callee) &&
+        (callee.text === "defineIONode" || callee.text === "defineConfigNode")
+      ) {
+        const arg = stmt.expression.arguments[0];
+        if (arg && ts.isObjectLiteralExpression(arg)) {
+          for (const prop of arg.properties) {
+            if (
+              ts.isPropertyAssignment(prop) &&
+              ts.isIdentifier(prop.name) &&
+              prop.name.text in SCHEMA_PROP_SEMANTICS
+            ) {
+              const ids = extractIdentifiers(prop.initializer);
+              if (ids.length > 0) {
+                schemaRefs.set(prop.name.text, ids);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Build result: match schema references to their import sources
+  const result: Array<{
+    localName: string;
+    semanticName: string;
+    importSource: string;
+    tupleProp?: string;
+  }> = [];
+  for (const [propName, identifiers] of schemaRefs) {
+    const semanticName = SCHEMA_PROP_SEMANTICS[propName];
+    const isArray = identifiers.length > 1;
+    for (const identifier of identifiers) {
+      const importSource = importMap.get(identifier);
+      if (importSource) {
+        result.push({
+          localName: identifier,
+          semanticName: isArray ? identifier : semanticName,
+          importSource,
+          tupleProp: isArray ? semanticName : undefined,
+        });
+      }
+    }
+  }
+  return result;
+}
+
 function buildNodeReexports(srcDir: string, entryFile: string): string {
   const nodesDir = path.join(srcDir, "nodes");
   const nodeFiles = collectTsFiles(nodesDir);
@@ -175,6 +308,7 @@ function buildNodeReexports(srcDir: string, entryFile: string): string {
 
       const lines = [`export { default as ${ns} } from "${specifier}";`];
 
+      // Re-export type aliases from the node file (class-based nodes)
       const typePairs = getNodeTypeExports(file);
       if (typePairs.length > 0) {
         const prefixed = typePairs
@@ -186,6 +320,29 @@ function buildNodeReexports(srcDir: string, entryFile: string): string {
         lines.push(`export type { ${prefixed} } from "${specifier}";`);
       }
 
+      // Re-export schemas referenced by the node definition (class or factory)
+      const schemaRefs = getSchemaReferences(file);
+      // Group by import source for cleaner re-exports
+      const bySource = new Map<string, string[]>();
+      for (const ref of schemaRefs) {
+        const resolvedSource = path
+          .relative(
+            path.dirname(entryFile),
+            path.resolve(path.dirname(file), ref.importSource),
+          )
+          .replace(/\\/g, "/");
+        const sourceSpecifier = resolvedSource.startsWith(".")
+          ? resolvedSource
+          : `./${resolvedSource}`;
+        if (!bySource.has(sourceSpecifier)) bySource.set(sourceSpecifier, []);
+        bySource
+          .get(sourceSpecifier)!
+          .push(`${ref.localName} as ${ns}${ref.semanticName}`);
+      }
+      for (const [source, names] of bySource) {
+        lines.push(`export { ${names.join(", ")} } from "${source}";`);
+      }
+
       return lines.join("\n");
     })
     .join("\n");