@bonsae/nrg 0.26.3 → 0.28.0

package/eslint/index.js

@@ -0,0 +1,48 @@
+// src/eslint/index.ts
+var nodeTypeMatchesFilename = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "require a node's static `type` to equal its filename in server/nodes"
+    },
+    schema: [],
+    messages: {
+      mismatch: `Node static type "{{type}}" must match the filename "{{expected}}.ts" \u2014 the type string keys the node's schema, component, icon and locale folder.`
+    }
+  },
+  create(context) {
+    const match = /[\\/]server[\\/]nodes[\\/]([^\\/]+)\.ts$/.exec(
+      context.filename
+    );
+    if (!match) return {};
+    const expected = match[1];
+    return {
+      "PropertyDefinition[static=true]"(node) {
+        if (node.key?.type === "Identifier" && node.key.name === "type" && node.value?.type === "Literal" && typeof node.value.value === "string" && node.value.value !== expected) {
+          context.report({
+            node: node.value,
+            messageId: "mismatch",
+            data: { type: node.value.value, expected }
+          });
+        }
+      }
+    };
+  }
+};
+var plugin = {
+  meta: { name: "@bonsae/nrg" },
+  rules: { "node-type-matches-filename": nodeTypeMatchesFilename }
+};
+var nrgConventions = {
+  plugins: { "@bonsae/nrg": plugin },
+  rules: {
+    "@bonsae/nrg/node-type-matches-filename": "error"
+  }
+};
+var index_default = nrgConventions;
+export {
+  index_default as default,
+  nodeTypeMatchesFilename,
+  nrgConventions,
+  plugin
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bonsae/nrg",
-  "version": "0.26.3",
+  "version": "0.28.0",
   "description": "NRG framework — build Node-RED nodes with Vue 3, TypeScript, and JSON Schema",
   "author": "Allan Oricil <allanoricil@duck.com>",
   "license": "MIT",
@@ -50,6 +50,7 @@
       "types": "./types/vite.d.ts",
       "default": "./vite/index.js"
     },
+    "./eslint": "./eslint/index.js",
     "./test/server/unit": {
       "types": "./types/test-server-unit.d.ts",
       "default": "./test/server/unit/index.js"

package/server/index.cjs

@@ -128,7 +128,8 @@ function setupConfigProxy(opts) {
         if (typeof prop === "symbol") return target[prop];
         if (SKIP_PROPS.has(prop)) return target[prop];
         const value = target[prop];
-        if (typeof value === "string" && value.length > 0 && nodeRefProps.has(prop)) {
+        if (nodeRefProps.has(prop)) {
+          if (typeof value !== "string" || value.length === 0) return void 0;
           return RED.nodes.getNode(value)?._node ?? value;
         }
         if (typedInputProps.has(prop) && value && typeof value === "object" && "type" in value && "value" in value) {
@@ -161,10 +162,16 @@ function getCredentialsFromSchema(schema) {
   const result = {};
   for (const [key, value] of Object.entries(schema.properties)) {
     const property = value;
+    const isPassword = property.format === "password";
+    if (!isPassword) {
+      console.warn(
+        `[nrg] credential "${key}" has no format:"password" \u2014 it is stored as a visible (cleartext-in-editor) credential. Add { format: "password" } to mask it.`
+      );
+    }
     result[key] = {
       // NOTE: required is always false because it is controlled by the JSON Schema and AJV validation instead of using node-red client core
       required: false,
-      type: property.format === "password" ? "password" : "text",
+      type: isPassword ? "password" : "text",
       value: property.default ?? void 0
     };
   }
@@ -253,6 +260,7 @@ var Node = class _Node {
           }
         );
         createdPromise.catch(() => {
+          this.status({ fill: "red", shape: "ring", text: "created() failed" });
         });
         node[WIRE_HANDLERS](this, createdPromise);
       },
@@ -453,14 +461,16 @@ function setupContext(context, store) {
       await set(key, next);
       return next;
     };
-    const run = (chains.get(lockKey) ?? Promise.resolve()).then(task, task);
-    chains.set(
-      lockKey,
-      run.then(
-        () => void 0,
-        () => void 0
-      )
+    const previous = chains.get(lockKey) ?? Promise.resolve();
+    const run = previous.then(task, task);
+    const settled = run.then(
+      () => void 0,
+      () => void 0
     );
+    chains.set(lockKey, settled);
+    void settled.then(() => {
+      if (chains.get(lockKey) === settled) chains.delete(lockKey);
+    });
     return run;
   };
   const increment = (key, by = 1) => {
@@ -579,36 +589,43 @@ var IONode = class _IONode extends Node {
       async (msg, send, done) => {
         try {
           await createdPromise;
-        } catch {
-          done(new Error("Node failed to initialize"));
+        } catch (initError) {
+          done(
+            initError instanceof Error ? initError : new Error(String(initError))
+          );
           return;
         }
+        const store = { inputMsg: msg, send };
         try {
           nodeRedNode.log("Calling input");
-          const result = await this.#input(msg, send);
-          this.#sendToPort("complete", {
-            ...msg,
-            ...result !== void 0 ? { output: result } : {},
-            complete: {
-              source: this.#nodeSource()
-            },
-            [INPUT_KEY]: msg
-          });
+          const result = await this.#input(msg, store);
+          if (this.config.completePort) {
+            this.#sendToPort("complete", {
+              ...msg,
+              ...result !== void 0 ? { output: result } : {},
+              complete: {
+                source: this.#nodeSource()
+              },
+              [INPUT_KEY]: msg
+            });
+          }
           done();
           nodeRedNode.log("Input processed");
         } catch (error) {
           const errorMsg = error instanceof Error ? error.message : "Unknown error during input handling";
-          const errorData = error && typeof error === "object" ? { ...error } : {};
-          this.#sendToPort("error", {
-            ...msg,
-            error: {
-              ...errorData,
-              name: error?.name ?? "Error",
-              message: errorMsg,
-              source: this.#nodeSource()
-            },
-            [INPUT_KEY]: msg
-          });
+          if (this.config.errorPort && !store.errorEmitted) {
+            const errorData = error && typeof error === "object" ? { ...error } : {};
+            this.#sendToPort("error", {
+              ...msg,
+              error: {
+                ...errorData,
+                name: error?.name ?? "Error",
+                message: errorMsg,
+                source: this.#nodeSource()
+              },
+              [INPUT_KEY]: msg
+            });
+          }
           if (error instanceof Error) {
             nodeRedNode.error(
               "Error while processing input: " + error.message,
@@ -629,7 +646,7 @@ var IONode = class _IONode extends Node {
   input(msg) {
     return void 0;
   }
-  async #input(msg, send) {
+  async #input(msg, store) {
     const NodeClass = this.constructor;
     const shouldValidateInput = this.config.validateInput ?? NodeClass.validateInput;
     if (shouldValidateInput && NodeClass.inputSchema) {
@@ -641,7 +658,7 @@ var IONode = class _IONode extends Node {
       this.log("Input is valid");
     }
     return await _IONode.#invocation.run(
-      { inputMsg: msg, send },
+      store,
       () => Promise.resolve(this.input(msg))
     );
   }
@@ -811,15 +828,20 @@ var IONode = class _IONode extends Node {
   }
   error(message, msg) {
     super.error(message, msg);
-    if (msg) {
+    if (msg && this.config.errorPort) {
       this.#sendToPort("error", {
         ...msg,
         error: {
+          // `name` keeps the error-port payload Catch-node compatible and
+          // consistent with the auto-emit from a thrown error.
+          name: "Error",
           message,
           source: this.#nodeSource()
         },
         [INPUT_KEY]: msg
       });
+      const store = _IONode.#invocation.getStore();
+      if (store) store.errorEmitted = true;
     }
   }
   updateWires(wires) {
@@ -1101,9 +1123,7 @@ function initValidator(RED) {
         }
       ],
       customFormats: {
-        "node-id": /^[a-zA-Z0-9-_]+$/,
-        "flow-id": /^[a-f0-9]{16}$/,
-        "topic-path": (data) => /^[a-zA-Z0-9/_-]+$/.test(data)
+        "node-id": /^[a-zA-Z0-9-_]+$/
       }
     })
   };
@@ -1205,35 +1225,140 @@ var TYPED_INPUT_TYPES = [
   "cred"
 ];
 
-// src/core/server/schemas/type.ts
+// src/core/shared/schemas/base.ts
 var import_typebox2 = require("@sinclair/typebox");
-var import_rules = require("ajv/dist/compile/rules.js");
-function NodeRef(nodeClass, options) {
+var NodeConfigSchema = import_typebox2.Type.Object({
+  id: import_typebox2.Type.String(),
+  type: import_typebox2.Type.String(),
+  name: import_typebox2.Type.String(),
+  z: import_typebox2.Type.Optional(import_typebox2.Type.String())
+});
+var ConfigNodeConfigSchema = import_typebox2.Type.Object({
+  ...NodeConfigSchema.properties,
+  _users: import_typebox2.Type.Array(import_typebox2.Type.String())
+});
+var IONodeConfigSchema = import_typebox2.Type.Object({
+  ...NodeConfigSchema.properties,
+  wires: import_typebox2.Type.Array(import_typebox2.Type.Array(import_typebox2.Type.String(), { default: [] }), {
+    default: [[]]
+  }),
+  x: import_typebox2.Type.Number(),
+  y: import_typebox2.Type.Number(),
+  g: import_typebox2.Type.Optional(import_typebox2.Type.String())
+});
+var TypedInputSchema = import_typebox2.Type.Object(
+  {
+    value: import_typebox2.Type.Union(
+      [
+        import_typebox2.Type.String(),
+        import_typebox2.Type.Number(),
+        import_typebox2.Type.Boolean(),
+        import_typebox2.Type.Null()
+      ],
+      {
+        description: "The actual value entered or selected.",
+        default: ""
+      }
+    ),
+    type: import_typebox2.Type.Union(
+      TYPED_INPUT_TYPES.map((type) => import_typebox2.Type.Literal(type)),
+      {
+        description: "The type of the value (string, number, message property, etc.)",
+        default: "str"
+      }
+    )
+  },
+  {
+    description: "Represents a Node-RED TypedInput value and its type.",
+    default: {
+      type: "str",
+      value: ""
+    }
+  }
+);
+var NodeSourceSchema = import_typebox2.Type.Object({
+  id: import_typebox2.Type.String(),
+  type: import_typebox2.Type.String(),
+  name: import_typebox2.Type.String()
+});
+var ErrorPortSchema = import_typebox2.Type.Object({
+  error: import_typebox2.Type.Object({
+    message: import_typebox2.Type.String(),
+    source: NodeSourceSchema
+  })
+});
+var CompletePortSchema = import_typebox2.Type.Object({
+  complete: import_typebox2.Type.Object({
+    source: NodeSourceSchema
+  })
+});
+var StatusPortSchema = import_typebox2.Type.Object({
+  status: import_typebox2.Type.Union([
+    import_typebox2.Type.Object({
+      fill: import_typebox2.Type.Optional(
+        import_typebox2.Type.Union([
+          import_typebox2.Type.Literal("red"),
+          import_typebox2.Type.Literal("green"),
+          import_typebox2.Type.Literal("yellow"),
+          import_typebox2.Type.Literal("blue"),
+          import_typebox2.Type.Literal("grey"),
+          import_typebox2.Type.Literal("gray")
+        ])
+      ),
+      shape: import_typebox2.Type.Optional(
+        import_typebox2.Type.Union([import_typebox2.Type.Literal("ring"), import_typebox2.Type.Literal("dot")])
+      ),
+      text: import_typebox2.Type.Optional(import_typebox2.Type.String())
+    }),
+    import_typebox2.Type.String()
+  ]),
+  source: NodeSourceSchema
+});
+
+// src/core/shared/schemas/type.ts
+var import_typebox3 = require("@sinclair/typebox");
+var JSON_TYPES = /* @__PURE__ */ new Set([
+  "null",
+  "boolean",
+  "object",
+  "array",
+  "number",
+  "integer",
+  "string"
+]);
+function isJSONType(value) {
+  return typeof value === "string" && JSON_TYPES.has(value);
+}
+function NodeRef(type, options) {
   return {
-    ...import_typebox2.Type.String({
-      description: options?.description || `Reference to ${nodeClass.type}`,
-      format: "node-id"
+    ...import_typebox3.Type.String({
+      description: options?.description || `Reference to ${type}`
     }),
-    "x-nrg-node-type": nodeClass.type,
+    // `...options` first so user options (description, x-nrg-form, …) apply, but
+    // the framework keys below win — a caller can't clobber `format`/
+    // `x-nrg-node-type`/`Kind` and silently break NodeRef resolution.
     ...options,
-    [import_typebox2.Kind]: "NodeRef"
+    format: "node-id",
+    "x-nrg-node-type": type,
+    [import_typebox3.Kind]: "NodeRef"
   };
 }
 function TypedInput2(options) {
   return {
     ...TypedInputSchema,
-    "x-nrg-typed-input": true,
+    // `...options` first; the framework key below wins (see NodeRef).
     ...options,
-    [import_typebox2.Kind]: "TypedInput"
+    "x-nrg-typed-input": true,
+    [import_typebox3.Kind]: "TypedInput"
   };
 }
 function NrgString(options) {
-  return import_typebox2.Type.String(options);
+  return import_typebox3.Type.String(options);
 }
 function OutputReturnProperties(options) {
-  return import_typebox2.Type.Record(
-    import_typebox2.Type.Number(),
-    import_typebox2.Type.String({ pattern: "^[A-Za-z_$][A-Za-z0-9_$]*$" }),
+  return import_typebox3.Type.Record(
+    import_typebox3.Type.Number(),
+    import_typebox3.Type.String({ pattern: "^[A-Za-z_$][A-Za-z0-9_$]*$" }),
     {
       description: "Per-port return property, keyed by output port index. A missing entry falls back to `output`.",
       default: {},
@@ -1242,12 +1367,12 @@ function OutputReturnProperties(options) {
   );
 }
 function OutputContextModes(options) {
-  return import_typebox2.Type.Record(
-    import_typebox2.Type.Number(),
-    import_typebox2.Type.Union([
-      import_typebox2.Type.Literal("carry"),
-      import_typebox2.Type.Literal("trace"),
-      import_typebox2.Type.Literal("reset")
+  return import_typebox3.Type.Record(
+    import_typebox3.Type.Number(),
+    import_typebox3.Type.Union([
+      import_typebox3.Type.Literal("carry"),
+      import_typebox3.Type.Literal("trace"),
+      import_typebox3.Type.Literal("reset")
     ]),
     {
       description: "Per-port context mode, keyed by output port index. A missing entry falls back to `carry`.",
@@ -1256,16 +1381,21 @@ function OutputContextModes(options) {
     }
   );
 }
-var SchemaType = Object.assign({}, import_typebox2.Type, {
+function NrgUnsafe(options) {
+  return import_typebox3.Type.Unsafe(options);
+}
+var NrgBuilders = {
   String: NrgString,
+  Unsafe: NrgUnsafe,
   NodeRef,
   TypedInput: TypedInput2,
   OutputReturnProperties,
   OutputContextModes
-});
+};
+var SchemaType = Object.assign({}, import_typebox3.Type, NrgBuilders);
 function markNonValidatable(schema) {
   const type = schema.type;
-  const hasInvalidType = type !== void 0 && (Array.isArray(type) ? !type.every(import_rules.isJSONType) : !(0, import_rules.isJSONType)(type));
+  const hasInvalidType = type !== void 0 && (Array.isArray(type) ? !type.every(isJSONType) : !isJSONType(type));
   if (hasInvalidType) {
     schema["x-nrg-skip-validation"] = true;
     if (schema.default !== void 0) {
@@ -1279,6 +1409,14 @@ function markNonValidatable(schema) {
       markNonValidatable(prop);
     }
   }
+  if (schema.patternProperties) {
+    for (const prop of Object.values(schema.patternProperties)) {
+      markNonValidatable(prop);
+    }
+  }
+  if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+    markNonValidatable(schema.additionalProperties);
+  }
   if (schema.items) {
     markNonValidatable(schema.items);
   }
@@ -1298,97 +1436,6 @@ function defineSchema(properties, options) {
   return markNonValidatable(schema);
 }
 
-// src/core/server/schemas/base.ts
-var NodeConfigSchema = SchemaType.Object({
-  id: SchemaType.String(),
-  type: SchemaType.String(),
-  name: SchemaType.String(),
-  z: SchemaType.Optional(SchemaType.String())
-});
-var ConfigNodeConfigSchema = SchemaType.Object({
-  ...NodeConfigSchema.properties,
-  _users: SchemaType.Array(SchemaType.String())
-});
-var IONodeConfigSchema = SchemaType.Object({
-  ...NodeConfigSchema.properties,
-  wires: SchemaType.Array(
-    SchemaType.Array(SchemaType.String(), { default: [] }),
-    {
-      default: [[]]
-    }
-  ),
-  x: SchemaType.Number(),
-  y: SchemaType.Number(),
-  g: SchemaType.Optional(SchemaType.String())
-});
-var TypedInputSchema = SchemaType.Object(
-  {
-    value: SchemaType.Union(
-      [
-        SchemaType.String(),
-        SchemaType.Number(),
-        SchemaType.Boolean(),
-        SchemaType.Null()
-      ],
-      {
-        description: "The actual value entered or selected.",
-        default: ""
-      }
-    ),
-    type: SchemaType.Union(
-      TYPED_INPUT_TYPES.map((type) => SchemaType.Literal(type)),
-      {
-        description: "The type of the value (string, number, message property, etc.)",
-        default: "str"
-      }
-    )
-  },
-  {
-    description: "Represents a Node-RED TypedInput value and its type.",
-    default: {
-      type: "str",
-      value: ""
-    }
-  }
-);
-var NodeSourceSchema = SchemaType.Object({
-  id: SchemaType.String(),
-  type: SchemaType.String(),
-  name: SchemaType.String()
-});
-var ErrorPortSchema = SchemaType.Object({
-  error: SchemaType.Object({
-    message: SchemaType.String(),
-    source: NodeSourceSchema
-  })
-});
-var CompletePortSchema = SchemaType.Object({
-  complete: SchemaType.Object({
-    source: NodeSourceSchema
-  })
-});
-var StatusPortSchema = SchemaType.Object({
-  status: SchemaType.Union([
-    SchemaType.Object({
-      fill: SchemaType.Optional(
-        SchemaType.Union([
-          SchemaType.Literal("red"),
-          SchemaType.Literal("green")
-        ])
-      ),
-      shape: SchemaType.Optional(
-        SchemaType.Union([
-          SchemaType.Literal("dot"),
-          SchemaType.Literal("string")
-        ])
-      ),
-      text: SchemaType.Optional(SchemaType.String())
-    }),
-    SchemaType.String()
-  ]),
-  source: NodeSourceSchema
-});
-
 // src/core/server/index.ts
 function defineModule(definition) {
   return definition;