@bonsae/nrg 0.6.1 → 0.6.3

package/src/core/validator.ts

@@ -1,222 +0,0 @@
-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/index.ts

@@ -1,2 +0,0 @@
-export { defineRuntimeSettings } from "./utils";
-export type { NodeRedRuntimeSettings } from "./types";

package/src/types.ts

@@ -1,189 +0,0 @@
-import type { Http2ServerRequest } from "http2";
-
-export interface NodeRedRuntimeSettings {
-  userDir?: string;
-  nodesDir?: string | string[];
-  flowFile?: string;
-  flowFilePretty?: boolean;
-  credentialSecret?: string | false;
-  requireHttps?: boolean;
-  https?:
-    | { key: string; cert: string }
-    | (() =>
-        | Promise<{ key: string; cert: string }>
-        | { key: string; cert: string });
-  httpsRefreshInterval?: number;
-  httpAdminRoot?: string;
-  httpNodeRoot?: string;
-  httpNodeCors?: { origin: string; methods: string };
-  httpStatic?: string | { path: string; root: string }[];
-  httpStaticRoot?: string;
-  httpAdminMiddleware?: (req: unknown, res: unknown, next: () => void) => void;
-  httpNodeMiddleware?: (req: unknown, res: unknown, next: () => void) => void;
-  httpServerOptions?: Record<string, unknown>;
-  adminAuth?: {
-    type?: "credentials" | "strategy";
-    users?: {
-      username: string;
-      password: string;
-      permissions?: string | string[];
-    }[];
-    default?: {
-      permissions?: string | string[];
-    };
-    tokens?: (
-      token: string,
-    ) => Promise<{ user: string; permissions: string | string[] } | null>;
-    tokenHeader: "string";
-    sessionExpiryTime?: number;
-    [key: string]: unknown;
-  };
-  httpNodeAuth?: {
-    user?: string;
-    pass?: string;
-  };
-  httpStaticAuth?: {
-    user?: string;
-    pass?: string;
-  };
-  lang?:
-    | "en-US"
-    | "de"
-    | "es-ES"
-    | "fr"
-    | "ko"
-    | "pt-BR"
-    | "ru"
-    | "ja"
-    | "zh-CN"
-    | "zh-TW";
-  diagnostics?: {
-    enabled?: boolean;
-    ui?: boolean;
-  };
-  runtimeState?: {
-    enabled?: boolean;
-    ui?: boolean;
-  };
-  disableEditor?: boolean;
-  editorTheme?: {
-    page?: {
-      title?: string;
-      favicon?: string;
-      css?: string | string[];
-      scripts?: string | string[];
-    };
-    header?: {
-      title?: string;
-      image?: string;
-      url?: string;
-    };
-    deployButton?: {
-      type?: "simple" | "default";
-      label?: string;
-      icon?: string;
-    };
-    menu?: {
-      "menu-item-import-library"?: boolean;
-      "menu-item-export-library"?: boolean;
-      "menu-item-keyboard-shortcuts"?: boolean;
-      "menu-item-help"?: {
-        label?: string;
-        url?: string;
-      };
-      [menuItem: string]:
-        | boolean
-        | { label?: string; url?: string }
-        | undefined;
-    };
-    userMenu?: boolean;
-    login?: {
-      image?: string;
-    };
-    logout?: {
-      redirect?: string;
-    };
-    palette?: {
-      catalogues?: string[];
-      categories?: string[];
-      theme?: { category: string; type: string; color: string }[];
-    };
-    projects?: {
-      enabled?: boolean;
-      workflow?: {
-        mode: "manual" | "auto";
-      };
-    };
-    codeEditor?: {
-      lib?: "monaco" | "ace";
-      options?: Record<string, unknown>;
-    };
-    mermaid?: {
-      theme?: string;
-    };
-    tours?: boolean;
-    theme?: string;
-    [key: string]: unknown;
-  };
-  contextStorage?: {
-    default?: {
-      module?: "memory" | "localfilesystem" | object;
-      config?: Record<string, unknown>;
-    };
-    [store: string]:
-      | {
-          module?: "memory" | "localfilesystem" | object;
-          config?: Record<string, unknown>;
-        }
-      | undefined;
-  };
-  exportGlobalContextKeys?: boolean;
-  logging?: {
-    console?: {
-      level?: "fatal" | "error" | "warn" | "info" | "debug" | "trace" | "off";
-      metrics?: boolean;
-      audit?: boolean;
-    };
-  };
-  fileWorkingDirectory?: string;
-  functionExternalModules?: boolean;
-  functionGlobalContext?: Record<string, unknown>;
-  nodeMessageBufferMaxLength?: number;
-  functionTimeout?: number;
-  externalModules?: {
-    autoInstall?: boolean;
-    autoInstallRetry?: number;
-    palette?: {
-      allowInstall?: boolean;
-      allowUpdate?: boolean;
-      allowUpload?: boolean;
-      allowList?: string[];
-      denyList?: string[];
-      allowUpdateList?: string[];
-      denyUpdateList?: string[];
-    };
-    modules?: {
-      allowInstall?: boolean;
-      allowList?: string[];
-      denyList?: string[];
-    };
-  };
-  execMaxBufferSize?: number;
-  debugMaxLength?: number;
-  debugUseColors?: boolean;
-  httpRequestTimeout?: number;
-  mqttReconnectTime?: number;
-  serialReconnectTime?: number;
-  socketReconnectTime?: number;
-  socketTimeout?: number;
-  tcpMsgQueueSize?: number;
-  inboundWebSocketTimeout?: number;
-  tlsConfigDisableLocalFiles?: boolean;
-  webSocketNodeVerifyClient?: (info: {
-    origin: string;
-    req: Http2ServerRequest;
-    secure: boolean;
-  }) => boolean;
-  apiMaxLength?: string;
-  [key: string]: unknown;
-}

package/src/utils.ts

@@ -1,20 +0,0 @@
-import type { NodeRedRuntimeSettings } from "./types";
-
-/**
- * Type-safe helper for defining Node-RED runtime settings.
- *
- * @example
- * ```typescript
- * import { defineRuntimeSettings } from "@bonsae/nrg";
- *
- * export default defineRuntimeSettings({
- *   flowFile: "flows.json",
- *   flowFilePretty: true,
- * });
- * ```
- */
-export function defineRuntimeSettings(
-  settings: NodeRedRuntimeSettings,
-): NodeRedRuntimeSettings {
-  return settings;
-}

package/src/vite/async-utils.ts

@@ -1,61 +0,0 @@
-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 };