@bonsae/nrg 0.6.0 → 0.6.2

package/src/core/server/schemas/type.ts

@@ -1,95 +0,0 @@
-import type {
-  TSchema,
-  TProperties,
-  SchemaOptions,
-  ObjectOptions,
-} from "@sinclair/typebox";
-import type { Schema } from "./types";
-import { Type as BaseType, Kind } from "@sinclair/typebox";
-import { TypedInputSchema } from "./base";
-import type { TNodeRef, TTypedInput } from "./types";
-import { isJSONType } from "ajv/dist/compile/rules";
-
-function NodeRef<T extends new (...args: any[]) => any>(
-  nodeClass: T,
-  options?: SchemaOptions,
-): TNodeRef<InstanceType<T>> {
-  return {
-    ...BaseType.String({
-      description:
-        options?.description || `Reference to ${(nodeClass as any).type}`,
-      format: "node-id",
-    }),
-    "x-nrg-node-type": (nodeClass as any).type,
-    ...options,
-    [Kind]: "NodeRef",
-  } as unknown as TNodeRef<InstanceType<T>>;
-}
-
-function TypedInput(options?: SchemaOptions): TTypedInput {
-  return {
-    ...TypedInputSchema,
-    ...options,
-    [Kind]: "TypedInput",
-  } as unknown as TTypedInput;
-}
-
-const SchemaType = Object.assign({}, BaseType, {
-  NodeRef,
-  TypedInput,
-});
-
-function markNonValidatable<T extends TSchema>(schema: T): T {
-  const type = (schema as any).type;
-
-  const hasInvalidType =
-    type !== undefined &&
-    (Array.isArray(type) ? !type.every(isJSONType) : !isJSONType(type));
-
-  // NOTE: if the type is non serializable, like Functions or Constructor, we must skip validation and avoid applying defaults
-  if (hasInvalidType) {
-    (schema as any)["x-nrg-skip-validation"] = true;
-
-    if ((schema as any).default !== undefined) {
-      (schema as any)._default = (schema as any).default;
-      delete (schema as any).default;
-    }
-
-    // NOTE: delete type to avoid the following error during validation => Error registering node types: Error: type must be JSONType or JSONType[]: Function
-    delete (schema as any).type;
-  }
-
-  if (schema.properties) {
-    for (const prop of Object.values(schema.properties)) {
-      markNonValidatable(prop as TSchema);
-    }
-  }
-
-  if (schema.items) {
-    markNonValidatable(schema.items as TSchema);
-  }
-
-  if (schema.anyOf) {
-    schema.anyOf.forEach((s) => markNonValidatable(s as TSchema));
-  }
-
-  if (schema.allOf) {
-    schema.allOf.forEach((s) => markNonValidatable(s as TSchema));
-  }
-
-  if (schema.oneOf) {
-    schema.oneOf.forEach((s) => markNonValidatable(s as TSchema));
-  }
-
-  return schema;
-}
-
-function defineSchema<T extends TProperties>(
-  properties: T,
-  options: ObjectOptions & { $id: string },
-): Schema<T> {
-  const schema = SchemaType.Object(properties, options);
-  return markNonValidatable(schema) as Schema<T>;
-}
-
-export { SchemaType, defineSchema };

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

@@ -1,82 +0,0 @@
-import type {
-  Kind,
-  TSchema,
-  TObject,
-  TProperties,
-  Static,
-} from "@sinclair/typebox";
-import type { TYPED_INPUT_TYPES } from "../../../constants";
-
-interface TNodeRef<T = any> extends TSchema {
-  [Kind]: "NodeRef";
-  static: T;
-  type: "string";
-  "x-nrg-node-type"?: string;
-}
-
-type ResolveNodeRefs<T> =
-  T extends TNodeRef<infer N>
-    ? N
-    : T extends (...args: any[]) => any
-      ? T
-      : T extends Array<infer Item>
-        ? ResolveNodeRefs<Item>[]
-        : T extends object
-          ? { [K in keyof T]: ResolveNodeRefs<T[K]> }
-          : T;
-
-type Infer<T extends TSchema> = ResolveNodeRefs<Static<T>>;
-
-type TypedInputType = (typeof TYPED_INPUT_TYPES)[number];
-
-interface TTypedInput extends TSchema {
-  [Kind]: "TypedInput";
-  static: {
-    value: string | number | boolean | null;
-    type: TypedInputType;
-  };
-}
-
-interface NrgFormOptions {
-  icon?: string;
-  typedInputTypes?: string[];
-  editorLanguage?: string;
-  toggle?: boolean;
-}
-
-declare module "@sinclair/typebox" {
-  interface SchemaOptions {
-    exportable?: boolean;
-    "x-nrg-node-type"?: string;
-    "x-nrg-form"?: NrgFormOptions;
-  }
-}
-
-interface Schema<T extends TProperties = TProperties> extends TObject<T> {
-  $id: string;
-}
-
-export { Infer, ResolveNodeRefs, TNodeRef, TTypedInput };
-export type { Schema };
-export type {
-  TSchema,
-  TObject,
-  TProperties,
-  TString,
-  TNumber,
-  TBoolean,
-  TArray,
-  TUnion,
-  TIntersect,
-  TLiteral,
-  TEnum,
-  TRecord,
-  TTuple,
-  TOptional,
-  TNull,
-  TInteger,
-  TRef,
-  TConst,
-  TFunction,
-  SchemaOptions,
-} from "@sinclair/typebox";

package/src/core/server/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "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

@@ -1,220 +0,0 @@
-import type { EventEmitter } from "events";
-import type { NodeRedRuntimeSettings } from "../../../types";
-
-// ---------------------------------------------------------------------------
-// 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;
-  };
-  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,
-    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;
-}
-
-export { RED, NodeRedNode, NodeRedNodeContext, NodeRedContextStore };

package/src/core/server/utils.ts

@@ -1,56 +0,0 @@
-import type { TObject, SchemaOptions } from "@sinclair/typebox";
-
-interface NodeSchemaOptions extends SchemaOptions {
-  "x-nrg-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["x-nrg-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

@@ -1,36 +0,0 @@
-import { Validator } from "../validator";
-import type { RED } from "./types";
-
-class NodeRedValidator extends Validator {
-  constructor(RED: RED) {
-    super({
-      customKeywords: [
-        {
-          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;
-            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);
-}