@bonsae/nrg 0.3.0 → 0.5.0

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

@@ -1,38 +1,204 @@
-import type { TObject } from "@sinclair/typebox";
+import type { EventEmitter } from "events";
+import type { NodeRedRuntimeSettings } from "../../../types";
 
-interface RED {
-  _: (key: string, substitutions?: Record<string, string>) => string;
-  log: {
-    info(msg: any): void;
-    warn(msg: any): void;
-    error(message: string, error: any): void;
-    debug(msg: any): void;
-    trace(msg: any): void;
-  };
-  nodes: {
-    registerType: (type: string, def: any, opts?: any) => void;
-    getNode: <T = any>(id: string) => T | undefined;
-    createNode: (node: any, config: Record<string, any>) => void;
-    getCredentials: (id: string) => Record<string, any> | undefined;
-  };
-  httpAdmin: {
-    get(path: string, handler: (req: any, res: any) => void): void;
-    post(path: string, handler: (req: any, res: any) => void): void;
-    put(path: string, handler: (req: any, res: any) => void): void;
-    delete(path: string, handler: (req: any, res: any) => void): void;
-  };
-  util: {
-    evaluateNodeProperty(
-      value: any,
-      type: string,
-      node: any,
-      msg: Record<string, any> | undefined,
-      callback: (err: Error | null, result: any) => void,
-    ): void;
+// ---------------------------------------------------------------------------
+// RED.log
+// ---------------------------------------------------------------------------
+
+interface NodeRedLog {
+  info(msg: any): void;
+  warn(msg: any): void;
+  error(msg: any, error?: any): void;
+  debug(msg: any): void;
+  trace(msg: any): void;
+  log(msg: { level: number; msg: string }): void;
+  metric(): boolean;
+  audit(msg: Record<string, any>, req?: any): void;
+  addHandler(handler: (msg: any) => void): void;
+  removeHandler(handler: (msg: any) => void): void;
+  FATAL: 10;
+  ERROR: 20;
+  WARN: 30;
+  INFO: 40;
+  DEBUG: 50;
+  TRACE: 60;
+  AUDIT: 98;
+  METRIC: 99;
+}
+
+// ---------------------------------------------------------------------------
+// Node-RED runtime node (the raw node object from RED.nodes.createNode)
+// ---------------------------------------------------------------------------
+
+interface NodeRedNode {
+  id: string;
+  type: string;
+  name?: string;
+  z?: string;
+  x: number;
+  y: number;
+  g?: string;
+  wires: string[][];
+  credentials: any;
+  _node?: any;
+  send(msg: any): void;
+  receive(msg: any): void;
+  status(
+    status: string | { fill?: string; shape?: string; text?: string },
+  ): void;
+  updateWires(wires: string[][]): void;
+  on(event: string, callback: (...args: any[]) => void): void;
+  log(msg: any): void;
+  warn(msg: any): void;
+  error(msg: any, errorMsg?: any): void;
+  context(): NodeRedNodeContext;
+  [key: string]: any;
+}
+
+interface NodeRedNodeContext extends NodeRedContextStore {
+  flow: NodeRedContextStore;
+  global: NodeRedContextStore;
+}
+
+// ---------------------------------------------------------------------------
+// RED.nodes
+// ---------------------------------------------------------------------------
+
+interface NodeRedNodes {
+  registerType(type: string, constructor: any, opts?: any): void;
+  getNode(id: string): (NodeRedNode & { _node?: any }) | undefined;
+  createNode(node: NodeRedNode, config: Record<string, any>): void;
+  getCredentials(id: string): Record<string, any> | undefined;
+  eachNode(callback: (node: any) => void): void;
+  getType(type: string): any;
+  getNodeInfo(type: string): any;
+  getNodeList(filter?: any): any[];
+  getModuleInfo(module: string): any;
+  installModule(module: string, version?: string): Promise<any>;
+  uninstallModule(module: string): Promise<any>;
+  enableNode(id: string): Promise<any>;
+  disableNode(id: string): Promise<any>;
+}
+
+// ---------------------------------------------------------------------------
+// RED.util
+// ---------------------------------------------------------------------------
+
+interface NodeRedUtil {
+  evaluateNodeProperty(
+    value: any,
+    type: string,
+    node: any,
+    msg: Record<string, any> | undefined,
+    callback: (err: Error | null, result: any) => void,
+  ): void;
+  generateId(): string;
+  cloneMessage<T = any>(msg: T): T;
+  ensureString(o: any): string;
+  ensureBuffer(o: any): Buffer;
+  compareObjects(obj1: any, obj2: any): boolean;
+  getMessageProperty(msg: any, expr: string): any;
+  setMessageProperty(
+    msg: any,
+    prop: string,
+    value: any,
+    createMissing?: boolean,
+  ): void;
+  getObjectProperty(obj: any, expr: string): any;
+  setObjectProperty(
+    obj: any,
+    prop: string,
+    value: any,
+    createMissing?: boolean,
+  ): void;
+  normalisePropertyExpression(
+    str: string,
+    msg?: any,
+    toString?: boolean,
+  ): string[];
+  normaliseNodeTypeName(name: string): string;
+  prepareJSONataExpression(value: string, node: any): any;
+  evaluateJSONataExpression(
+    expr: any,
+    msg: any,
+    callback: (err: Error | null, result: any) => void,
+  ): void;
+  parseContextStore(key: string): {
+    store: string | undefined;
+    key: string;
   };
-  settings: Record<string, any>;
+  getSetting(node: any, name: string, flow?: any): any;
+  encodeObject(obj: any): any;
+}
+
+// ---------------------------------------------------------------------------
+// RED.hooks
+// ---------------------------------------------------------------------------
+
+interface NodeRedHooks {
+  add(hookId: string, callback: (event: any) => void | Promise<void>): void;
+  remove(hookId: string): void;
+  trigger(
+    hookId: string,
+    event: any,
+    callback?: (err?: Error) => void,
+  ): void | Promise<void>;
+  has(hookId: string): boolean;
+  clear(): void;
+}
+
+// ---------------------------------------------------------------------------
+// Express-like HTTP app (httpAdmin / httpNode)
+// ---------------------------------------------------------------------------
+
+type NodeRedRequestHandler = (req: any, res: any, next?: () => void) => void;
+
+interface NodeRedExpressApp {
+  get(path: string, ...handlers: NodeRedRequestHandler[]): void;
+  post(path: string, ...handlers: NodeRedRequestHandler[]): void;
+  put(path: string, ...handlers: NodeRedRequestHandler[]): void;
+  delete(path: string, ...handlers: NodeRedRequestHandler[]): void;
+  patch(path: string, ...handlers: NodeRedRequestHandler[]): void;
+  options(path: string, ...handlers: NodeRedRequestHandler[]): void;
+  head(path: string, ...handlers: NodeRedRequestHandler[]): void;
+  use(
+    path: string | NodeRedRequestHandler,
+    ...handlers: NodeRedRequestHandler[]
+  ): void;
+  all(path: string, ...handlers: NodeRedRequestHandler[]): void;
+}
+
+// ---------------------------------------------------------------------------
+// RED (main interface)
+// ---------------------------------------------------------------------------
+
+interface RED {
+  /** Internationalization function */
+  _(key: string, substitutions?: Record<string, string>): string;
+  /** Logging API */
+  log: NodeRedLog;
+  /** Node registry and management */
+  nodes: NodeRedNodes;
+  /** Utility functions */
+  util: NodeRedUtil;
+  /** Hook system for message lifecycle and module events */
+  hooks: NodeRedHooks;
+  /** Runtime event emitter */
+  events: EventEmitter;
+  /** Express app for admin HTTP endpoints */
+  httpAdmin: NodeRedExpressApp;
+  /** Express app for node HTTP endpoints */
+  httpNode: NodeRedExpressApp;
+  /** Runtime settings (user-provided settings plus node-registered settings) */
+  settings: NodeRedRuntimeSettings & Record<string, any>;
+  /** Node-RED version string */
+  version(): string;
 }
 
+// ---------------------------------------------------------------------------
+// Context store (internal)
+// ---------------------------------------------------------------------------
+
 interface NodeRedContextStore {
   get(
     key: string,
@@ -51,23 +217,4 @@ interface NodeRedContextStore {
   ): void;
 }
 
-interface NodeDefinitionApiResponse {
-  type: string;
-  align?: "left" | "right";
-  category?: "config" | string;
-  color?: `#${string}`;
-  icon?: string;
-  labelStyle?: "node_label" | "node_label_italic" | string;
-  paletteLabel?: string;
-  inputs?: number;
-  outputs?: number;
-  inputLabels?: string | string[];
-  outputLabels?: string | string[];
-  configSchema: TObject | null;
-  credentialsSchema: TObject | null;
-  inputSchema?: TObject | null;
-  outputsSchema?: TObject | null;
-  settingsSchema?: TObject | null;
-}
-
-export { RED, NodeDefinitionApiResponse, NodeRedContextStore };
+export { RED, NodeRedNode, NodeRedNodeContext, NodeRedContextStore };

package/src/core/server/utils.ts

@@ -1,7 +1,7 @@
 import type { TObject, SchemaOptions } from "@sinclair/typebox";
 
 interface NodeSchemaOptions extends SchemaOptions {
-  "node-type"?: string;
+  "x-nrg-node-type"?: string;
   default?: any;
   format?: string;
 }
@@ -25,7 +25,7 @@ function getDefaultsFromSchema(
       required: false,
       value: property.default ?? undefined,
       // NOTE: I'm using a custom json schema keyword to determine the node type
-      type: property["node-type"],
+      type: property["x-nrg-node-type"],
     };
   }
 

package/src/core/server/validator.ts

@@ -5,9 +5,13 @@ class NodeRedValidator extends Validator {
   constructor(RED: RED) {
     super({
       customKeywords: [
-        { keyword: "skip-validation", schemaType: "boolean", valid: true },
         {
-          keyword: "node-type",
+          keyword: "x-nrg-skip-validation",
+          schemaType: "boolean",
+          valid: true,
+        },
+        {
+          keyword: "x-nrg-node-type",
           type: "string",
           validate: (schemaValue: string, dataValue: string) => {
             if (!dataValue) return true;

package/src/vite/client/build.ts

@@ -39,13 +39,15 @@ async function build(
   if (fs.existsSync(physicalEntryPath)) {
     entryPath = physicalEntryPath;
   } else {
-    // No physical entry — create a minimal empty file that the inliner
-    // will prepend auto-registration code into.
-    if (!fs.existsSync(path.dirname(physicalEntryPath))) {
-      fs.mkdirSync(path.dirname(physicalEntryPath), { recursive: true });
+    // No physical entry — create a minimal empty file in the cache directory
+    // so the file watcher on srcDir is not triggered by the create/delete cycle.
+    const cacheDir = path.resolve("node_modules", ".nrg", "client");
+    const cachedEntryPath = path.resolve(cacheDir, entry);
+    if (!fs.existsSync(cacheDir)) {
+      fs.mkdirSync(cacheDir, { recursive: true });
     }
-    fs.writeFileSync(physicalEntryPath, "// auto-generated entry\n");
-    entryPath = physicalEntryPath;
+    fs.writeFileSync(cachedEntryPath, "// auto-generated entry\n");
+    entryPath = cachedEntryPath;
     generatedEntry = true;
   }
 
@@ -215,7 +217,7 @@ async function build(
     throw new BuildError("client", error as Error);
   } finally {
     if (generatedEntry) {
-      fs.unlinkSync(physicalEntryPath);
+      fs.unlinkSync(entryPath);
     }
   }
 }

package/src/vite/client/plugins/node-definitions-inliner.ts

@@ -28,7 +28,7 @@ function getDefaultsFromSchema(
     result[key] = {
       required: false,
       value: prop.default ?? undefined,
-      type: prop["node-type"],
+      type: prop["x-nrg-node-type"],
     };
   }
   return result;

package/src/core/client/api/index.ts

@@ -1,17 +0,0 @@
-import { type NodeDefinitionApiResponse } from "../../server/types";
-
-async function fetchNodeDefinition(
-  type: string,
-): Promise<NodeDefinitionApiResponse> {
-  const response = await fetch(`/nrg/nodes/${type}`);
-
-  if (!response.ok) {
-    throw new Error(
-      `Failed to fetch node definition for "${type}": ${response.status}`,
-    );
-  }
-
-  return response.json() as Promise<NodeDefinitionApiResponse>;
-}
-
-export { fetchNodeDefinition };

package/src/core/client/virtual.d.ts

@@ -1,5 +0,0 @@
-declare module "virtual:nrg/node-definitions" {
-  import type { NodeDefinitionApiResponse } from "../server/types";
-  const definitions: Record<string, NodeDefinitionApiResponse>;
-  export default definitions;
-}