@bonsae/nrg 0.1.0

package/src/core/server/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "noImplicitAny": false,
+    "noImplicitOverride": true,
+    "resolveJsonModule": true
+  },
+  "include": ["**/*.ts", "../constants.ts", "../validator.ts"],
+  "exclude": ["node_modules"]
+}

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

@@ -0,0 +1,73 @@
+import type { TObject } from "@sinclair/typebox";
+
+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;
+  };
+  settings: Record<string, any>;
+}
+
+interface NodeRedContextStore {
+  get(
+    key: string,
+    store: string | undefined,
+    callback: (err: Error | null, value: any) => void,
+  ): void;
+  set(
+    key: string,
+    value: any,
+    store: string | undefined,
+    callback: (err: Error | null) => void,
+  ): void;
+  keys(
+    store: string | undefined,
+    callback: (err: Error | null, keys: string[]) => void,
+  ): 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 };

package/src/core/server/utils.ts

@@ -0,0 +1,56 @@
+import type { TObject, SchemaOptions } from "@sinclair/typebox";
+
+interface NodeSchemaOptions extends SchemaOptions {
+  "node-type"?: string;
+  default?: any;
+  format?: string;
+}
+
+function getDefaultsFromSchema(
+  schema: TObject,
+): Record<string, { type?: string; required: boolean; value: any }> {
+  const result: Record<
+    string,
+    { type?: string; required: boolean; value: any }
+  > = {};
+
+  for (const [key, value] of Object.entries(schema.properties)) {
+    // NOTE: these are excluded from defaults because they must be set by the editor
+    if (["x", "y", "z", "g", "wires", "type", "id"].includes(key)) continue;
+
+    const property = value as NodeSchemaOptions;
+
+    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,
+      value: property.default ?? undefined,
+      // NOTE: I'm using a custom json schema keyword to determine the node type
+      type: property["node-type"],
+    };
+  }
+
+  return result;
+}
+
+function getCredentialsFromSchema(
+  schema: TObject,
+): Record<string, { type: string; required: boolean; value: any }> {
+  const result: Record<
+    string,
+    { type: string; required: boolean; value: any }
+  > = {};
+
+  for (const [key, value] of Object.entries(schema.properties)) {
+    const property = value as NodeSchemaOptions;
+    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",
+      value: property.default ?? undefined,
+    };
+  }
+
+  return result;
+}
+
+export { getDefaultsFromSchema, getCredentialsFromSchema };

package/src/core/server/validator.ts

@@ -0,0 +1,32 @@
+import { Validator } from "../validator";
+import type { RED } from "./types";
+
+class NodeRedValidator extends Validator {
+  constructor(RED: RED) {
+    super({
+      customKeywords: [
+        { keyword: "skip-validation", schemaType: "boolean", valid: true },
+        {
+          keyword: "node-type",
+          type: "string",
+          validate: (schemaValue: string, dataValue: string) => {
+            if (!dataValue) return true;
+            const node = RED.nodes.getNode(dataValue);
+            return node?.type === schemaValue;
+          },
+        },
+      ],
+      customFormats: {
+        "node-id": /^[a-zA-Z0-9-_]+$/,
+        "flow-id": /^[a-f0-9]{16}$/,
+        "topic-path": (data: string) => /^[a-zA-Z0-9/_-]+$/.test(data),
+      },
+    });
+  }
+}
+
+export let validator: NodeRedValidator = undefined!;
+
+export function initValidator(RED: RED): void {
+  validator = new NodeRedValidator(RED);
+}

package/src/core/validator.ts

@@ -0,0 +1,222 @@
+import type {
+  Options,
+  ErrorObject,
+  ErrorsTextOptions,
+  AnySchemaObject,
+  ValidateFunction,
+  KeywordDefinition,
+} from "ajv";
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import addErrors from "ajv-errors";
+
+interface ValidationResult<T = unknown> {
+  valid: boolean;
+  data?: T;
+  errors?: ErrorObject[];
+  errorMessage?: string;
+}
+
+interface ValidatorOptions extends Options {
+  customKeywords?: string[] | KeywordDefinition[];
+  customFormats?: Record<string, RegExp | ((data: string) => boolean)>;
+}
+
+interface DetailedError {
+  field: string;
+  message: string;
+  keyword: string;
+  params: Record<string, unknown>;
+  schemaPath: string;
+}
+
+interface ValidateOption {
+  cacheKey?: string;
+  throwOnError?: boolean;
+}
+
+class Validator {
+  private readonly ajv: Ajv;
+
+  public constructor(options?: ValidatorOptions) {
+    const { customKeywords, customFormats, ...ajvOptions } = options || {};
+
+    this.ajv = new Ajv({
+      allErrors: true,
+      code: {
+        source: false,
+      },
+      coerceTypes: true,
+      removeAdditional: false,
+      strict: false,
+      strictSchema: false,
+      useDefaults: true,
+      validateFormats: true,
+      // NOTE: typebox handles validation via typescript
+      // NOTE: if true, types that are not serializable JSON, like Function, would not work
+      validateSchema: false,
+      verbose: true,
+      ...ajvOptions,
+    });
+
+    addFormats(this.ajv);
+    addErrors(this.ajv);
+
+    this.addCustomKeywords(customKeywords || []);
+    this.addCustomFormats(customFormats || {});
+  }
+
+  /**
+   * Add custom keywords to the validator
+   */
+  private addCustomKeywords(keywords?: string[] | KeywordDefinition[]): void {
+    if (!keywords) return;
+    keywords.forEach((keyword) => {
+      this.ajv.addKeyword(keyword);
+    });
+  }
+
+  /**
+   * Add custom formats to the validator
+   */
+  private addCustomFormats(
+    formats?: Record<string, RegExp | ((data: string) => boolean)>,
+  ): void {
+    if (!formats) return;
+
+    Object.entries(formats).forEach(([name, validator]) => {
+      if (validator instanceof RegExp) {
+        this.ajv.addFormat(name, validator);
+      } else {
+        this.ajv.addFormat(name, { validate: validator });
+      }
+    });
+  }
+
+  /**
+   * Create a validator function with caching
+   * @param schema - JSON Schema to validate against
+   * @param cacheKey - Optional cache key for reusing validators
+   */
+  public createValidator(
+    schema: AnySchemaObject,
+    cacheKey?: string,
+  ): ValidateFunction {
+    if (cacheKey && !schema.$id) {
+      schema.$id = cacheKey;
+    }
+
+    if (schema.$id) {
+      const cached = this.ajv.getSchema(schema.$id);
+      if (cached) return cached;
+    }
+
+    const validator = this.ajv.compile(schema);
+
+    return validator;
+  }
+
+  /**
+   * Validate data against a schema and return a structured result
+   */
+  public validate<T = unknown>(
+    data: unknown,
+    schema: AnySchemaObject,
+    options?: ValidateOption,
+  ): ValidationResult<T> {
+    const validator = this.createValidator(schema, options?.cacheKey);
+    const valid = validator(data);
+
+    if (!valid) {
+      const errorMessage = this.formatErrors(validator.errors);
+
+      if (options?.throwOnError) {
+        throw new ValidationError(errorMessage, validator.errors || []);
+      }
+
+      return {
+        valid: false,
+        errors: validator.errors || undefined,
+        errorMessage,
+      };
+    }
+
+    return {
+      valid: true,
+      data: data as T,
+    };
+  }
+
+  /**
+   * Format errors into a human-readable string
+   */
+  public formatErrors(
+    errors?: ErrorObject[] | null,
+    options?: ErrorsTextOptions,
+  ): string {
+    if (!errors || errors.length === 0) {
+      return "No errors";
+    }
+
+    return this.ajv.errorsText(errors, {
+      separator: "; ",
+      dataVar: "data",
+      ...options,
+    });
+  }
+
+  /**
+   * Get detailed error information
+   */
+  public getDetailedErrors(errors?: ErrorObject[] | null): DetailedError[] {
+    if (!errors || errors.length === 0) return [];
+
+    return errors.map((error) => ({
+      field: error.instancePath || "/",
+      message: error.message || "Validation failed",
+      keyword: error.keyword,
+      params: error.params,
+      schemaPath: error.schemaPath,
+    }));
+  }
+
+  /**
+   * Add a schema to the validator for reference
+   */
+  public addSchema(schema: AnySchemaObject, key?: string): this {
+    this.ajv.addSchema(schema, key);
+    return this;
+  }
+
+  /**
+   * Remove a schema from the validator
+   */
+  public removeSchema(key: string): this {
+    this.ajv.removeSchema(key);
+    return this;
+  }
+}
+
+/**
+ * Custom error class for validation errors
+ */
+class ValidationError extends Error {
+  constructor(
+    message: string,
+    public readonly errors: ErrorObject[],
+  ) {
+    super(message);
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, ValidationError.prototype);
+  }
+}
+
+const validator = new Validator();
+
+export { Validator, ValidationError, validator };
+export type {
+  ValidationResult,
+  ValidatorOptions,
+  ValidateOption,
+  DetailedError,
+};

package/src/tsconfig/base.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "allowJs": false,
+    "allowSyntheticDefaultImports": true,
+    "checkJs": false,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "noEmit": true,
+    "noImplicitAny": false,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "stripInternal": true,
+    "target": "ES2022"
+  },
+  "exclude": ["node_modules", "dist"]
+}

package/src/tsconfig/client.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./base.json",
+  "compilerOptions": {
+    "lib": ["ES2022", "DOM", "DOM.Iterable"]
+  },
+  "files": [
+    "../core/client/shims-vue.d.ts",
+    "../core/client/components.d.ts",
+    "../core/client/globals.d.ts"
+  ]
+}

package/src/tsconfig/server.json

@@ -0,0 +1,6 @@
+{
+  "extends": "./base.json",
+  "compilerOptions": {
+    "lib": ["ES2022"]
+  }
+}

package/src/vite/async-utils.ts

@@ -0,0 +1,61 @@
+function debounce<T extends (...args: any[]) => any>(
+  fn: T,
+  delay: number,
+): (...args: Parameters<T>) => void {
+  let timeout: NodeJS.Timeout | null = null;
+
+  return (...args: Parameters<T>) => {
+    if (timeout) clearTimeout(timeout);
+    timeout = setTimeout(() => fn(...args), delay);
+  };
+}
+
+function withTimeout<T>(
+  promise: Promise<T>,
+  ms: number,
+  fallback?: T,
+): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      if (fallback !== undefined) {
+        resolve(fallback);
+      } else {
+        reject(new Error(`Timeout after ${ms}ms`));
+      }
+    }, ms);
+
+    promise
+      .then((result) => {
+        clearTimeout(timeout);
+        resolve(result);
+      })
+      .catch((error) => {
+        clearTimeout(timeout);
+        reject(error);
+      });
+  });
+}
+
+async function retry<T>(
+  fn: () => Promise<T>,
+  options: { attempts?: number; delay?: number } = {},
+): Promise<T> {
+  const { attempts = 3, delay = 1000 } = options;
+
+  let lastError: Error | undefined;
+
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error as Error;
+      if (i < attempts - 1) {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+export { debounce, withTimeout, retry };