@bonsae/nrg 0.6.0 → 0.6.2

package/src/core/server/nodes/node.ts

@@ -1,259 +0,0 @@
-import type { Schema } from "../schemas/types";
-import { type RED, type NodeRedNode } from "../../server/types";
-import type {
-  ConfigNodeContext,
-  IONodeContext,
-  NodeConfig,
-  NodeCredentials,
-  TypedInput,
-  NodeSettings,
-} from "./types";
-import { validator } from "../validator";
-import { setupConfigProxy } from "./utils";
-
-abstract class Node<TConfig = any, TCredentials = any, TSettings = any> {
-  public static readonly type: string;
-  public static readonly category: "config" | string;
-  public static readonly configSchema?: Schema;
-  public static readonly credentialsSchema?: Schema;
-  public static readonly settingsSchema?: Schema;
-
-  private static _cachedSettings: any = null;
-
-  public static registered?(RED: RED): void | Promise<void>;
-
-  /** @internal */
-  public static _registered?(RED: RED): void | Promise<void>;
-
-  /** @internal */
-  public static _settings(): NodeSettings | undefined {
-    if (!this.settingsSchema) return;
-
-    const settings: NodeSettings = {};
-    const prefix = this.type.replace(/-./g, (x) => x[1].toUpperCase());
-    for (const [key, prop] of Object.entries(this.settingsSchema.properties)) {
-      const settingKey = prefix + key.charAt(0).toUpperCase() + key.slice(1);
-      settings[settingKey] = {
-        value: prop.default,
-        exportable: prop.exportable ?? false,
-      };
-    }
-    return settings;
-  }
-
-  // NOTE:
-  public static validateSettings(RED: RED): void {
-    if (!this.settingsSchema) return;
-
-    RED.log.info("Validating settings");
-    const prefix = this.type.replace(/-./g, (x) => x[1].toUpperCase());
-    const properties = this.settingsSchema.properties;
-    const settings: Record<string, unknown> = {};
-
-    for (const key of Object.keys(properties)) {
-      const settingKey = prefix + key.charAt(0).toUpperCase() + key.slice(1);
-      const value = RED.settings[settingKey];
-
-      if (value !== undefined) {
-        settings[key] = value;
-      }
-    }
-
-    // NOTE: assign defaults manually to avoid ajv errors for non json types (eg. Function, Constructor)
-    for (const [key, prop] of Object.entries(properties) as [string, any][]) {
-      if (settings[key] === undefined) {
-        // NOTE: here I need to use _default when it is a non validatable type (eg. Function, Constructor...)
-        const defaultValue = prop.default ?? prop._default;
-        if (defaultValue !== undefined) {
-          settings[key] = defaultValue;
-        }
-      }
-    }
-
-    validator.validate(settings, this.settingsSchema, {
-      cacheKey: this.settingsSchema.$id || `${this.type}:settings`,
-      throwOnError: true,
-    });
-
-    this._cachedSettings = settings;
-
-    RED.log.info("Settings are valid");
-  }
-  protected readonly RED: RED;
-  protected readonly node: NodeRedNode;
-  protected readonly context!: ConfigNodeContext | IONodeContext;
-  public readonly config!: NodeConfig<TConfig>;
-
-  private readonly timers = new Set<NodeJS.Timeout>();
-  private readonly intervals = new Set<NodeJS.Timeout>();
-
-  constructor(
-    RED: RED,
-    node: NodeRedNode,
-    config: NodeConfig<TConfig>,
-    credentials: NodeCredentials<TCredentials>,
-  ) {
-    this.RED = RED;
-    this.node = node;
-
-    const constructor = this.constructor as typeof Node;
-    if (constructor.configSchema) {
-      this.log("Validating configs");
-      const configResult = validator.validate(
-        config,
-        constructor.configSchema,
-        {
-          cacheKey:
-            constructor.configSchema.$id ||
-            `${constructor.type}:configs-schema`,
-          throwOnError: false,
-        },
-      );
-      if (!configResult.valid && configResult.errors?.length) {
-        this.warn(
-          `Config validation errors: ${configResult.errors.map((e) => `${e.instancePath} ${e.message}`).join("; ")}`,
-        );
-      }
-    }
-    (this as any).config = setupConfigProxy(
-      RED,
-      config,
-      constructor.configSchema,
-    );
-
-    if (constructor.credentialsSchema && credentials) {
-      this.log("Validating credentials");
-      const credResult = validator.validate(
-        credentials,
-        constructor.credentialsSchema,
-        {
-          cacheKey:
-            constructor.credentialsSchema.$id ||
-            `${constructor.type}:credentials-schema`,
-          throwOnError: false,
-        },
-      );
-      if (!credResult.valid && credResult.errors?.length) {
-        this.warn(
-          `Credentials validation errors: ${credResult.errors.map((e) => `${e.instancePath} ${e.message}`).join("; ")}`,
-        );
-      }
-    }
-  }
-
-  public i18n(key: string, substitutions?: Record<string, string>): string {
-    const nodeType = (this.constructor as typeof Node).type;
-    return this.RED._(`${nodeType}.${key}`, substitutions);
-  }
-
-  public setTimeout(fn: () => void, ms: number): NodeJS.Timeout {
-    const timer = setTimeout(() => {
-      this.timers.delete(timer);
-      fn();
-    }, ms);
-    this.timers.add(timer);
-    return timer;
-  }
-
-  public setInterval(fn: () => void, ms: number): NodeJS.Timeout {
-    const interval = setInterval(fn, ms);
-    this.intervals.add(interval);
-    return interval;
-  }
-
-  public clearTimeout(timer: NodeJS.Timeout): void {
-    clearTimeout(timer);
-    this.timers.delete(timer);
-  }
-
-  public clearInterval(interval: NodeJS.Timeout): void {
-    clearInterval(interval);
-    this.intervals.delete(interval);
-  }
-
-  public created?(): void | Promise<void>;
-  public closed?(removed?: boolean): void | Promise<void>;
-
-  // NOTE: typing msg isnt necessary in this case
-  public resolveTypedInput<T = any>(
-    typedInput: TypedInput,
-    msg?: Record<string, any>,
-  ): Promise<T> {
-    return new Promise((resolve, reject) => {
-      this.RED.util.evaluateNodeProperty(
-        typedInput.value,
-        typedInput.type,
-        this.node,
-        msg,
-        (error: Error | null, result: any) => {
-          if (error) {
-            reject(error);
-            return;
-          }
-
-          // NOTE: some references might have not been written with the nrg framework
-          // TODO: type with NodeRedNode for nodes that don't have types
-          if (typedInput.type === "node" && result) {
-            resolve((result._node ?? result) as T);
-            return;
-          }
-
-          resolve(result as T);
-        },
-      );
-    });
-  }
-  // NOTE: used by the registered function. Had to be a different one to avoid calling the parent's closed again
-  /** @internal */
-  public async _closed(removed?: boolean) {
-    try {
-      await Promise.resolve(this.closed?.(removed));
-    } finally {
-      this.log("clearing timers and intervals");
-      this.timers.forEach((t) => clearTimeout(t));
-      this.intervals.forEach((i) => clearInterval(i));
-      this.timers.clear();
-      this.intervals.clear();
-      this.log("timers and intervals cleared");
-    }
-  }
-
-  public on(event: string, callback: (...args: any[]) => void) {
-    this.node.on(event, callback);
-  }
-
-  public log(msg: any) {
-    this.node.log(msg);
-  }
-
-  public warn(message: string) {
-    this.node.warn(message);
-  }
-
-  public error(message: string, msg?: any) {
-    this.node.error(message, msg);
-  }
-
-  public get id(): string {
-    return this.node.id;
-  }
-
-  public get name(): string | undefined {
-    return this.node.name;
-  }
-
-  public get z(): string | undefined {
-    return this.node.z;
-  }
-
-  public get credentials(): NodeCredentials<TCredentials> | undefined {
-    return this.node.credentials;
-  }
-
-  public get settings(): TSettings {
-    const constructor = this.constructor as typeof Node;
-    return (constructor._cachedSettings as TSettings) ?? ({} as TSettings);
-  }
-}
-
-export { Node };

package/src/core/server/nodes/types/config-node.ts

@@ -1,28 +0,0 @@
-import type { Static } from "@sinclair/typebox";
-import type {
-  NodeConfig,
-  NodeCredentials,
-  NodeContextScope,
-  NodeContextStore,
-} from "../../../server/nodes/types";
-import type { ConfigNodeConfigSchema } from "../../schemas";
-
-type ConfigNodeContextScope = Exclude<NodeContextScope, "flow">;
-
-type ConfigNodeConfig<TConfig = any> = NodeConfig<TConfig> &
-  Static<typeof ConfigNodeConfigSchema>;
-
-type ConfigNodeCredentials<TCredentials = any> = NodeCredentials<TCredentials>;
-
-type ConfigNodeContext = {
-  (scope: ConfigNodeContextScope, store?: string): NodeContextStore;
-  node: NodeContextStore;
-  global: NodeContextStore;
-};
-
-export {
-  ConfigNodeConfig,
-  ConfigNodeContext,
-  ConfigNodeCredentials,
-  ConfigNodeContextScope,
-};

package/src/core/server/nodes/types/factories.ts

@@ -1,115 +0,0 @@
-import { type Static, type TSchema } from "@sinclair/typebox";
-import type { RED } from "../../types";
-import type { IONode } from "../io-node";
-import type { ConfigNode } from "../config-node";
-import type { HexColor } from "./io-node";
-
-type InferOr<T, Fallback> = T extends TSchema ? Static<T> : Fallback;
-
-type InferOutputs<T> = T extends readonly TSchema[]
-  ? { [K in keyof T]: T[K] extends TSchema ? Static<T[K]> : never }
-  : T extends TSchema
-    ? Static<T>
-    : any;
-
-type BoundIONode<
-  TC extends TSchema | undefined,
-  TCr extends TSchema | undefined,
-  TS extends TSchema | undefined,
-  TIn extends TSchema | undefined,
-  TOut extends TSchema | readonly TSchema[] | undefined,
-> = IONode<
-  InferOr<TC, any>,
-  InferOr<TCr, any>,
-  InferOr<TIn, any>,
-  InferOutputs<TOut>,
-  InferOr<TS, any>
->;
-
-type BoundConfigNode<
-  TC extends TSchema | undefined,
-  TCr extends TSchema | undefined,
-  TS extends TSchema | undefined,
-> = ConfigNode<InferOr<TC, any>, InferOr<TCr, any>, InferOr<TS, any>>;
-
-interface IONodeDefinition<
-  TConfigSchema extends TSchema | undefined = undefined,
-  TCredsSchema extends TSchema | undefined = undefined,
-  TSettingsSchema extends TSchema | undefined = undefined,
-  TInputSchema extends TSchema | undefined = undefined,
-  TOutputsSchema extends TSchema | readonly TSchema[] | undefined = undefined,
-> {
-  type: string;
-  category?: string;
-  color?: HexColor;
-  inputs?: 0 | 1;
-  outputs?: number;
-  paletteLabel?: string;
-  inputLabels?: string | string[];
-  outputLabels?: string | string[];
-  align?: "left" | "right";
-  labelStyle?: string;
-
-  configSchema?: TConfigSchema;
-  credentialsSchema?: TCredsSchema;
-  settingsSchema?: TSettingsSchema;
-  inputSchema?: TInputSchema;
-  outputsSchema?: TOutputsSchema;
-
-  validateInput?: boolean;
-  validateOutput?: boolean;
-
-  registered?(RED: RED): void | Promise<void>;
-  created?(
-    this: BoundIONode<
-      TConfigSchema,
-      TCredsSchema,
-      TSettingsSchema,
-      TInputSchema,
-      TOutputsSchema
-    >,
-  ): void | Promise<void>;
-  closed?(
-    this: BoundIONode<
-      TConfigSchema,
-      TCredsSchema,
-      TSettingsSchema,
-      TInputSchema,
-      TOutputsSchema
-    >,
-    removed?: boolean,
-  ): void | Promise<void>;
-  input(
-    this: BoundIONode<
-      TConfigSchema,
-      TCredsSchema,
-      TSettingsSchema,
-      TInputSchema,
-      TOutputsSchema
-    >,
-    msg: InferOr<TInputSchema, any>,
-  ): void | Promise<void>;
-}
-
-interface ConfigNodeDefinition<
-  TConfigSchema extends TSchema | undefined = undefined,
-  TCredsSchema extends TSchema | undefined = undefined,
-  TSettingsSchema extends TSchema | undefined = undefined,
-> {
-  type: string;
-
-  configSchema?: TConfigSchema;
-  credentialsSchema?: TCredsSchema;
-  settingsSchema?: TSettingsSchema;
-
-  registered?(RED: RED): void | Promise<void>;
-  created?(
-    this: BoundConfigNode<TConfigSchema, TCredsSchema, TSettingsSchema>,
-  ): void | Promise<void>;
-  closed?(
-    this: BoundConfigNode<TConfigSchema, TCredsSchema, TSettingsSchema>,
-    removed?: boolean,
-  ): void | Promise<void>;
-}
-
-export type { InferOr, InferOutputs, IONodeDefinition, ConfigNodeDefinition };

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

@@ -1,4 +0,0 @@
-export * from "./node";
-export * from "./io-node";
-export * from "./config-node";
-export type * from "./factories";

package/src/core/server/nodes/types/io-node.ts

@@ -1,40 +0,0 @@
-import type { Static } from "@sinclair/typebox";
-import type { IONodeConfigSchema } from "../../schemas";
-import type {
-  NodeConfig,
-  NodeCredentials,
-  NodeContextStore,
-  NodeContextScope,
-} from "../../../server/nodes/types";
-
-type IONodeContextScope = NodeContextScope;
-
-type IONodeConfig<TConfig = any> = NodeConfig<TConfig> &
-  Static<typeof IONodeConfigSchema> & {
-    validateInput?: boolean;
-    validateOutput?: boolean;
-  };
-
-type IONodeCredentials<TCredentials = any> = NodeCredentials<TCredentials>;
-
-type IONodeStatus =
-  | { fill?: "red" | "green"; shape?: "dot" | "string"; text?: string }
-  | string;
-
-type IONodeContext = {
-  (scope: IONodeContextScope, store?: string): NodeContextStore;
-  node: NodeContextStore;
-  flow: NodeContextStore;
-  global: NodeContextStore;
-};
-
-type HexColor = `#${string}`;
-
-export {
-  HexColor,
-  IONodeConfig,
-  IONodeContext,
-  IONodeContextScope,
-  IONodeCredentials,
-  IONodeStatus,
-};

package/src/core/server/nodes/types/node.ts

@@ -1,41 +0,0 @@
-import type { Static } from "@sinclair/typebox";
-import type { NodeConfigSchema, TTypedInput } from "../../schemas";
-import type { RED } from "../../../server/types";
-
-type NodeContextScope = "node" | "flow" | "global";
-
-interface NodeContextStore {
-  get<T = any>(key: string): Promise<T>;
-  set<T = any>(key: string, value: T): Promise<void>;
-  keys(): Promise<string[]>;
-}
-
-type NodeConstructor<T = any> = (new (...args: any[]) => T) & {
-  type: string;
-  registered?(RED: RED): void | Promise<void>;
-};
-
-type NodeConfig<TConfig = any> = TConfig & Static<typeof NodeConfigSchema>;
-
-type NodeCredentials<TCredentials = any> = TCredentials;
-
-interface NodeSetting<T = any> {
-  value: T;
-  exportable?: boolean;
-}
-
-type NodeSettings = Record<string, NodeSetting>;
-
-// TODO: move this somewhere else
-type TypedInput = Static<TTypedInput>;
-
-export {
-  NodeConfig,
-  NodeContextStore,
-  NodeContextScope,
-  NodeConstructor,
-  NodeCredentials,
-  NodeSetting,
-  NodeSettings,
-  TypedInput,
-};

package/src/core/server/nodes/utils.ts

@@ -1,106 +0,0 @@
-import type { ResolveNodeRefs } from "../schemas/types";
-import type { RED, NodeRedContextStore } from "../types";
-import type { NodeContextStore } from "./types";
-import { NrgError } from "../../errors";
-
-function setupContext(
-  context: NodeRedContextStore,
-  store?: string,
-): NodeContextStore {
-  return {
-    get: (key) =>
-      new Promise((resolve, reject) =>
-        context.get(key, store, (error, value) =>
-          error ? reject(error) : resolve(value),
-        ),
-      ),
-
-    set: (key, value) =>
-      new Promise((resolve, reject) =>
-        context.set(key, value, store, (error) =>
-          error ? reject(error) : resolve(),
-        ),
-      ),
-
-    keys: () =>
-      new Promise((resolve, reject) =>
-        context.keys(store, (error, k) => (error ? reject(error) : resolve(k))),
-      ),
-  };
-}
-
-function setupConfigProxy<T extends object>(
-  RED: RED,
-  config: T,
-  schema?: any,
-): ResolveNodeRefs<T> {
-  const SKIP_PROPS = new Set(["id", "_id", "_users"]);
-
-  // Build a set of property names that are node references based on the schema.
-  // Only these properties will have their string values resolved via RED.nodes.getNode().
-  const nodeRefProps = new Set<string>();
-  if (schema?.properties) {
-    for (const [key, propSchema] of Object.entries(schema.properties)) {
-      if ((propSchema as any)?.["x-nrg-node-type"]) {
-        nodeRefProps.add(key);
-      }
-    }
-  }
-
-  // Per-node-instance cache: original object/array -> proxy or mapped array.
-  // This preserves reference equality: config.server === config.server
-  const cache = new WeakMap<object, any>();
-
-  const createProxy = <O extends object>(obj: O): any => {
-    const cached = cache.get(obj);
-    if (cached) return cached;
-
-    if (Array.isArray(obj)) {
-      // Map once, cache the result array so identity is stable across reads
-      const mapped = obj.map((item) => {
-        if (item && typeof item === "object") {
-          return createProxy(item);
-        }
-        return item;
-      });
-      cache.set(obj, mapped);
-      return mapped;
-    }
-
-    const proxy = new Proxy(obj, {
-      get(target: any, prop: string | symbol): any {
-        if (typeof prop === "symbol") return target[prop];
-        if (SKIP_PROPS.has(prop)) return target[prop];
-
-        const value = target[prop];
-
-        // Only resolve strings as node references if the schema marks the property
-        if (
-          typeof value === "string" &&
-          value.length > 0 &&
-          nodeRefProps.has(prop)
-        ) {
-          return RED.nodes.getNode(value)?._node ?? value;
-        }
-
-        if (value && typeof value === "object") {
-          return createProxy(value); // hits the cache on repeat access
-        }
-
-        return value;
-      },
-      set(_target: any, prop: string | symbol): boolean {
-        throw new NrgError(
-          `Cannot set property '${String(prop)}' on read-only node config`,
-        );
-      },
-    });
-
-    cache.set(obj, proxy);
-    return proxy;
-  };
-
-  return createProxy(config) as ResolveNodeRefs<T>;
-}
-
-export { setupConfigProxy, setupContext };

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

@@ -1,66 +0,0 @@
-import { TYPED_INPUT_TYPES } from "../../constants";
-import { SchemaType } from "./type";
-
-const NodeConfigSchema = SchemaType.Object({
-  id: SchemaType.String(),
-  type: SchemaType.String(),
-  name: SchemaType.String(),
-  z: SchemaType.Optional(SchemaType.String()),
-});
-
-const ConfigNodeConfigSchema = SchemaType.Object({
-  ...NodeConfigSchema.properties,
-  _users: SchemaType.Array(SchemaType.String()),
-});
-
-const 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()),
-});
-
-const 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: "",
-    },
-  },
-);
-
-export {
-  ConfigNodeConfigSchema,
-  IONodeConfigSchema,
-  NodeConfigSchema,
-  TypedInputSchema,
-};

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

@@ -1,3 +0,0 @@
-export * from "./base";
-export * from "./type";
-export type * from "./types";