@bonsae/create-nrg 0.4.0 → 0.5.0

package/dist/index.js

@@ -7,65 +7,99 @@ import { dashCase, scaffoldProject } from "./scaffold.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const TEMPLATES_DIR = path.resolve(__dirname, "../templates");
+export function parseArgs(argv) {
+    const result = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--inputs") {
+            result.hasInputs = true;
+        }
+        else if (arg === "--no-inputs") {
+            result.hasInputs = false;
+        }
+        else if (arg === "--no-outputs") {
+            result.outputs = "0";
+        }
+        else if (arg.startsWith("--")) {
+            const key = arg.slice(2);
+            const next = argv[i + 1];
+            if (next && !next.startsWith("-")) {
+                result[key] = next;
+                i++;
+            }
+            else {
+                result[key] = true;
+            }
+        }
+    }
+    return result;
+}
 async function main() {
     p.intro("Create a new NRG project");
     const args = process.argv.slice(2);
     const positionalName = args.find((a) => !a.startsWith("-"));
+    const parsed = parseArgs(args);
     const project = await p.group({
-        projectName: () => p.text({
-            message: "What would you like to name your project?",
-            placeholder: "nrg-project",
-            defaultValue: positionalName || "nrg-project",
-            initialValue: positionalName,
-            validate: (value) => {
-                if (!value?.trim())
-                    return "Project name is required.";
-            },
-        }),
-        nodeName: () => p.text({
-            message: "What would you like to name your first node?",
-            placeholder: "node-1",
-            defaultValue: "node-1",
-            validate: (value) => {
-                if (!value?.trim())
-                    return "Node name is required.";
-            },
-        }),
-        nodeCategory: () => p.text({
-            message: "Which category should your node belong to?",
-            placeholder: "new category",
-            defaultValue: "new category",
-        }),
-        nodeColor: () => p.text({
-            message: "What color should represent your node? (hex)",
-            placeholder: "#1A1A1A",
-            defaultValue: "#1A1A1A",
-            validate: (value) => {
-                if (!value || !/^#([0-9A-F]{3}|[0-9A-F]{6})$/i.test(value)) {
-                    return "Please enter a valid hex color code (e.g., #1A1A1A or #000)";
-                }
-            },
-        }),
-        nodeInputs: () => p.text({
-            message: "How many inputs should your node have? (0 or 1)",
-            placeholder: "1",
-            defaultValue: "1",
-            validate: (value) => {
-                const n = parseInt(value || "", 10);
-                if (n !== 0 && n !== 1)
-                    return "Inputs must be either 0 or 1.";
-            },
-        }),
-        nodeOutputs: () => p.text({
-            message: "How many outputs should your node have?",
-            placeholder: "1",
-            defaultValue: "1",
-            validate: (value) => {
-                const n = parseInt(value || "", 10);
-                if (isNaN(n) || n < 0)
-                    return "Outputs must be 0 or more.";
-            },
-        }),
+        projectName: () => parsed.name
+            ? Promise.resolve(parsed.name)
+            : p.text({
+                message: "What would you like to name your project?",
+                placeholder: "nrg-project",
+                defaultValue: positionalName || "nrg-project",
+                initialValue: positionalName,
+                validate: (value) => {
+                    if (!value?.trim())
+                        return "Project name is required.";
+                },
+            }),
+        nodeName: () => parsed.node
+            ? Promise.resolve(parsed.node)
+            : p.text({
+                message: "What would you like to name your first node?",
+                placeholder: "node-1",
+                defaultValue: "node-1",
+                validate: (value) => {
+                    if (!value?.trim())
+                        return "Node name is required.";
+                },
+            }),
+        nodeCategory: () => parsed.category
+            ? Promise.resolve(parsed.category)
+            : p.text({
+                message: "Which category should your node belong to?",
+                placeholder: "new category",
+                defaultValue: "new category",
+            }),
+        nodeColor: () => parsed.color
+            ? Promise.resolve(parsed.color)
+            : p.text({
+                message: "What color should represent your node? (hex)",
+                placeholder: "#1A1A1A",
+                defaultValue: "#1A1A1A",
+                validate: (value) => {
+                    if (!value || !/^#([0-9A-F]{3}|[0-9A-F]{6})$/i.test(value)) {
+                        return "Please enter a valid hex color code (e.g., #1A1A1A or #000)";
+                    }
+                },
+            }),
+        hasInputs: () => parsed.hasInputs !== undefined
+            ? Promise.resolve(parsed.hasInputs)
+            : p.confirm({
+                message: "Does your node receive messages? (has an input port)",
+                initialValue: true,
+            }),
+        nodeOutputs: () => parsed.outputs
+            ? Promise.resolve(parsed.outputs)
+            : p.text({
+                message: "How many output ports should your node have?",
+                placeholder: "1",
+                defaultValue: "1",
+                validate: (value) => {
+                    const n = parseInt(value || "", 10);
+                    if (isNaN(n) || n < 0)
+                        return "Outputs must be 0 or more.";
+                },
+            }),
     }, {
         onCancel: () => {
             p.cancel("Operation cancelled.");
@@ -76,8 +110,8 @@ async function main() {
     const nodeName = project.nodeName;
     const nodeCategory = project.nodeCategory;
     const nodeColor = project.nodeColor;
-    const nodeInputs = project.nodeInputs;
-    const nodeOutputs = project.nodeOutputs;
+    const hasInputs = project.hasInputs;
+    const nodeOutputs = parseInt(project.nodeOutputs, 10);
     const projectDir = path.resolve(process.cwd(), dashCase(projectName));
     if (fs.existsSync(projectDir)) {
         p.cancel(`Directory "${dashCase(projectName)}" already exists.`);
@@ -90,7 +124,7 @@ async function main() {
         nodeName,
         nodeCategory,
         nodeColor,
-        nodeInputs,
+        hasInputs,
         nodeOutputs,
     });
     s.stop("Project scaffolded.");

package/dist/scaffold.js

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import Handlebars from "handlebars";
 export function dashCase(str) {
     return str
         .replace(/([a-z])([A-Z])/g, "$1-$2")
@@ -13,7 +14,8 @@ export function pascalCase(str) {
         .join("");
 }
 export function renderTemplate(content, vars) {
-    return content.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? _);
+    const template = Handlebars.compile(content, { noEscape: true });
+    return template(vars);
 }
 export function copyTemplateDir(srcDir, destDir, vars) {
     const entries = fs.readdirSync(srcDir, { withFileTypes: true });
@@ -41,15 +43,25 @@ export function renderTemplateFile(templatePath, destPath, vars) {
     fs.writeFileSync(destPath, renderTemplate(content, vars));
 }
 export function scaffoldProject(destDir, templatesDir, options) {
+    const dashCaseNodeName = dashCase(options.nodeName);
+    const pascalCaseNodeName = pascalCase(options.nodeName);
+    const outputPorts = Array.from({ length: options.nodeOutputs }, (_, i) => ({
+        index: i + 1,
+        schemaName: `OutputPort${i + 1}Schema`,
+    }));
     const vars = {
         projectName: dashCase(options.projectName),
         nodeName: options.nodeName,
-        dashCaseNodeName: dashCase(options.nodeName),
-        pascalCaseNodeName: pascalCase(options.nodeName),
+        dashCaseNodeName,
+        pascalCaseNodeName,
         nodeCategory: options.nodeCategory,
         nodeColor: options.nodeColor,
-        nodeInputs: options.nodeInputs,
+        hasInputs: options.hasInputs,
         nodeOutputs: options.nodeOutputs,
+        hasSingleOutput: options.nodeOutputs === 1,
+        hasMultipleOutputs: options.nodeOutputs > 1,
+        hasOutputs: options.nodeOutputs > 0,
+        outputPorts,
     };
     fs.mkdirSync(destDir, { recursive: true });
     // Copy project-level templates (includes directory structure with READMEs)
@@ -57,9 +69,9 @@ export function scaffoldProject(destDir, templatesDir, options) {
     // Place node-specific files into the correct locations
     const nodeTemplatesDir = path.join(templatesDir, "node");
     const srcDir = path.join(destDir, "src");
-    renderTemplateFile(path.join(nodeTemplatesDir, "server-node.ts.hbs"), path.join(srcDir, "server", "nodes", `${vars.dashCaseNodeName}.ts`), vars);
-    renderTemplateFile(path.join(nodeTemplatesDir, "schema.ts.hbs"), path.join(srcDir, "server", "schemas", `${vars.dashCaseNodeName}.ts`), vars);
+    renderTemplateFile(path.join(nodeTemplatesDir, "server-node.ts.hbs"), path.join(srcDir, "server", "nodes", `${dashCaseNodeName}.ts`), vars);
+    renderTemplateFile(path.join(nodeTemplatesDir, "schema.ts.hbs"), path.join(srcDir, "server", "schemas", `${dashCaseNodeName}.ts`), vars);
     renderTemplateFile(path.join(nodeTemplatesDir, "server-index.ts.hbs"), path.join(srcDir, "server", "index.ts"), vars);
-    renderTemplateFile(path.join(nodeTemplatesDir, "labels.json.hbs"), path.join(srcDir, "locales", "labels", vars.dashCaseNodeName, "en-US.json"), vars);
-    renderTemplateFile(path.join(nodeTemplatesDir, "docs.md.hbs"), path.join(srcDir, "locales", "docs", vars.dashCaseNodeName, "en-US.md"), vars);
+    renderTemplateFile(path.join(nodeTemplatesDir, "labels.json.hbs"), path.join(srcDir, "locales", "labels", dashCaseNodeName, "en-US.json"), vars);
+    renderTemplateFile(path.join(nodeTemplatesDir, "docs.md.hbs"), path.join(srcDir, "locales", "docs", dashCaseNodeName, "en-US.md"), vars);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bonsae/create-nrg",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Scaffold a new NRG project for Node-RED",
   "author": "Allan Oricil <allanoricil@duck.com>",
   "license": "MIT",
@@ -41,7 +41,8 @@
     "prepare": "husky"
   },
   "dependencies": {
-    "@clack/prompts": "^1.0.1"
+    "@clack/prompts": "^1.0.1",
+    "handlebars": "^4.7.9"
   },
   "devDependencies": {
     "@commitlint/cli": "^20.5.0",

package/templates/node/schema.ts.hbs

@@ -15,20 +15,38 @@ const CredentialsSchema = defineSchema(
     $id: "{{pascalCaseNodeName}}CredentialsSchema",
   },
 );
+{{#if hasInputs}}
 
+// TODO: define the properties your node expects to receive
 const InputSchema = defineSchema(
   {},
   {
     $id: "{{pascalCaseNodeName}}InputSchema",
   },
 );
+{{/if}}
+{{#if hasSingleOutput}}
 
+// TODO: define the properties your node sends
 const OutputSchema = defineSchema(
   {},
   {
     $id: "{{pascalCaseNodeName}}OutputSchema",
   },
 );
+{{/if}}
+{{#if hasMultipleOutputs}}
+{{#each outputPorts}}
+
+// TODO: define the properties for output port {{index}}
+const OutputPort{{index}}Schema = defineSchema(
+  {},
+  {
+    $id: "{{../pascalCaseNodeName}}OutputPort{{index}}Schema",
+  },
+);
+{{/each}}
+{{/if}}
 
 const SettingsSchema = defineSchema(
   {},
@@ -37,4 +55,4 @@ const SettingsSchema = defineSchema(
   },
 );
 
-export { ConfigsSchema, CredentialsSchema, InputSchema, OutputSchema, SettingsSchema };
+export { ConfigsSchema, CredentialsSchema, {{#if hasInputs}}InputSchema, {{/if}}{{#if hasSingleOutput}}OutputSchema, {{/if}}{{#if hasMultipleOutputs}}{{#each outputPorts}}OutputPort{{index}}Schema, {{/each}}{{/if}}SettingsSchema };

package/templates/node/server-node.ts.hbs

@@ -3,35 +3,64 @@ import { IONode } from "@bonsae/nrg/server";
 import {
   ConfigsSchema,
   CredentialsSchema,
+{{#if hasInputs}}
   InputSchema,
+{{/if}}
+{{#if hasSingleOutput}}
   OutputSchema,
+{{/if}}
+{{#if hasMultipleOutputs}}
+{{#each outputPorts}}
+  OutputPort{{index}}Schema,
+{{/each}}
+{{/if}}
   SettingsSchema,
 } from "../schemas/{{dashCaseNodeName}}";
 
 export type Config = Infer<typeof ConfigsSchema>;
 export type Credentials = Infer<typeof CredentialsSchema>;
+{{#if hasInputs}}
 export type Input = Infer<typeof InputSchema>;
+{{/if}}
+{{#if hasSingleOutput}}
 export type Output = Infer<typeof OutputSchema>;
+{{/if}}
 export type Settings = Infer<typeof SettingsSchema>;
 
 export default class {{pascalCaseNodeName}} extends IONode<
   Config,
   Credentials,
+{{#if hasInputs}}
   Input,
+{{else}}
+  any,
+{{/if}}
+{{#if hasSingleOutput}}
   Output,
+{{else}}
+  any,
+{{/if}}
   Settings
 > {
   public static override readonly type: string = "{{dashCaseNodeName}}";
   public static override readonly category: string = "{{nodeCategory}}";
   public static override readonly color: `#${string}` = "{{nodeColor}}";
-  public static override readonly inputs: number = {{nodeInputs}};
-  public static override readonly outputs: number = {{nodeOutputs}};
 
   public static override readonly configSchema: Schema = ConfigsSchema;
   public static override readonly credentialsSchema: Schema = CredentialsSchema;
+  public static override readonly settingsSchema: Schema = SettingsSchema;
+{{#if hasInputs}}
+  // TODO: define the schema for incoming messages
   public static override readonly inputSchema: Schema = InputSchema;
+{{/if}}
+{{#if hasSingleOutput}}
+  // TODO: define the schema for outgoing messages
   public static override readonly outputsSchema: Schema = OutputSchema;
-  public static override readonly settingsSchema: Schema = SettingsSchema;
+{{/if}}
+{{#if hasMultipleOutputs}}
+  // TODO: define the schema for each output port
+  public static override readonly outputsSchema: Schema[] = [{{#each outputPorts}}OutputPort{{index}}Schema{{#unless @last}}, {{/unless}}{{/each}}];
+{{/if}}
 
   public static override async registered(RED: RED): Promise<void> {
     RED.log.info(`${this.type} registered`);
@@ -40,10 +69,13 @@ export default class {{pascalCaseNodeName}} extends IONode<
   public override created(): void {
     this.log(`{{pascalCaseNodeName}} ${this.id} created`);
   }
+{{#if hasInputs}}
 
   public override async input(msg: Input): Promise<void> {
-    this.send(msg as unknown as Output);
+    // TODO: implement your node logic here
+    this.send(msg as any);
   }
+{{/if}}
 
   public override async closed(): Promise<void> {
     this.log(`{{pascalCaseNodeName}} ${this.id} closed`);