@graph-knowledge/api 0.1.2 → 0.1.3

package/src/lib/validators/element-type-validators/text-validator.js

@@ -1,23 +1,26 @@
-import { ValidationError } from "../../errors/api-errors";
-import { BaseElementValidator } from "./base-element-validator";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextValidator = void 0;
+const api_errors_1 = require("../../errors/api-errors");
+const base_element_validator_1 = require("./base-element-validator");
 /**
  * Validator for text elements.
  */
-export class TextValidator extends BaseElementValidator {
+class TextValidator extends base_element_validator_1.BaseElementValidator {
     elementType = "text";
     validate(input) {
         if (input.type !== "text") {
-            throw new ValidationError(`Expected type "text", got "${input.type}"`, "type");
+            throw new api_errors_1.ValidationError(`Expected type "text", got "${input.type}"`, "type");
         }
         const textInput = input;
         // Validate common properties
         this.validateCommon(textInput);
         // Text content is required
         if (textInput.text === undefined || textInput.text === null) {
-            throw new ValidationError("text is required for text elements", "text");
+            throw new api_errors_1.ValidationError("text is required for text elements", "text");
         }
         if (typeof textInput.text !== "string") {
-            throw new ValidationError("text must be a string", "text");
+            throw new api_errors_1.ValidationError("text must be a string", "text");
         }
         // Validate text-specific properties
         this.validateColor(textInput.fillColor, "fillColor");
@@ -30,37 +33,38 @@ export class TextValidator extends BaseElementValidator {
         if (value === undefined)
             return;
         if (typeof value !== "number" || isNaN(value)) {
-            throw new ValidationError("fontSize must be a valid number", "fontSize");
+            throw new api_errors_1.ValidationError("fontSize must be a valid number", "fontSize");
         }
         if (value <= 0) {
-            throw new ValidationError("fontSize must be positive", "fontSize");
+            throw new api_errors_1.ValidationError("fontSize must be positive", "fontSize");
         }
     }
     validateFontWeight(value) {
         if (value === undefined)
             return;
         if (typeof value !== "number" || isNaN(value)) {
-            throw new ValidationError("fontWeight must be a valid number", "fontWeight");
+            throw new api_errors_1.ValidationError("fontWeight must be a valid number", "fontWeight");
         }
         if (value < 100 || value > 900) {
-            throw new ValidationError("fontWeight must be between 100 and 900", "fontWeight");
+            throw new api_errors_1.ValidationError("fontWeight must be between 100 and 900", "fontWeight");
         }
     }
     validateTextAlign(value) {
         if (value === undefined)
             return;
         if (!["left", "center", "right"].includes(value)) {
-            throw new ValidationError('textAlign must be "left", "center", or "right"', "textAlign");
+            throw new api_errors_1.ValidationError('textAlign must be "left", "center", or "right"', "textAlign");
         }
     }
     validateLineHeight(value) {
         if (value === undefined)
             return;
         if (typeof value !== "number" || isNaN(value)) {
-            throw new ValidationError("lineHeight must be a valid number", "lineHeight");
+            throw new api_errors_1.ValidationError("lineHeight must be a valid number", "lineHeight");
         }
         if (value <= 0) {
-            throw new ValidationError("lineHeight must be positive", "lineHeight");
+            throw new api_errors_1.ValidationError("lineHeight must be positive", "lineHeight");
         }
     }
 }
+exports.TextValidator = TextValidator;

package/src/lib/validators/element-type-validators/uml-validators.js

@@ -1,13 +1,16 @@
-import { ValidationError } from "../../errors/api-errors";
-import { BaseElementValidator } from "./base-element-validator";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UmlNoteValidator = exports.UmlArtifactValidator = exports.UmlPackageValidator = exports.UmlComponentValidator = exports.UmlInterfaceValidator = exports.UmlClassValidator = void 0;
+const api_errors_1 = require("../../errors/api-errors");
+const base_element_validator_1 = require("./base-element-validator");
 /**
  * Base validator for UML elements.
  * Provides common validation for UML-specific properties.
  */
-class BaseUmlValidator extends BaseElementValidator {
+class BaseUmlValidator extends base_element_validator_1.BaseElementValidator {
     validate(input) {
         if (input.type !== this.elementType) {
-            throw new ValidationError(`Expected type "${this.elementType}", got "${input.type}"`, "type");
+            throw new api_errors_1.ValidationError(`Expected type "${this.elementType}", got "${input.type}"`, "type");
         }
         // Validate common properties - cast is safe since we've verified the type
         // and UML elements always have required x/y
@@ -30,94 +33,100 @@ class BaseUmlValidator extends BaseElementValidator {
 /**
  * Validator for UML class elements.
  */
-export class UmlClassValidator extends BaseUmlValidator {
+class UmlClassValidator extends BaseUmlValidator {
     elementType = "uml-class";
     validateSpecific(input) {
         const classInput = input;
         if (classInput["name"] !== undefined &&
             typeof classInput["name"] !== "string") {
-            throw new ValidationError("name must be a string", "name");
+            throw new api_errors_1.ValidationError("name must be a string", "name");
         }
         if (classInput["attributes"] !== undefined &&
             typeof classInput["attributes"] !== "string") {
-            throw new ValidationError("attributes must be a string", "attributes");
+            throw new api_errors_1.ValidationError("attributes must be a string", "attributes");
         }
         if (classInput["methods"] !== undefined &&
             typeof classInput["methods"] !== "string") {
-            throw new ValidationError("methods must be a string", "methods");
+            throw new api_errors_1.ValidationError("methods must be a string", "methods");
         }
         if (classInput["stereotype"] !== undefined &&
             typeof classInput["stereotype"] !== "string") {
-            throw new ValidationError("stereotype must be a string", "stereotype");
+            throw new api_errors_1.ValidationError("stereotype must be a string", "stereotype");
         }
     }
 }
+exports.UmlClassValidator = UmlClassValidator;
 /**
  * Validator for UML interface elements.
  */
-export class UmlInterfaceValidator extends BaseUmlValidator {
+class UmlInterfaceValidator extends BaseUmlValidator {
     elementType = "uml-interface";
     validateSpecific(input) {
         const interfaceInput = input;
         if (interfaceInput["name"] !== undefined &&
             typeof interfaceInput["name"] !== "string") {
-            throw new ValidationError("name must be a string", "name");
+            throw new api_errors_1.ValidationError("name must be a string", "name");
         }
         if (interfaceInput["methods"] !== undefined &&
             typeof interfaceInput["methods"] !== "string") {
-            throw new ValidationError("methods must be a string", "methods");
+            throw new api_errors_1.ValidationError("methods must be a string", "methods");
         }
     }
 }
+exports.UmlInterfaceValidator = UmlInterfaceValidator;
 /**
  * Validator for UML component elements.
  */
-export class UmlComponentValidator extends BaseUmlValidator {
+class UmlComponentValidator extends BaseUmlValidator {
     elementType = "uml-component";
     validateSpecific(input) {
         const componentInput = input;
         if (componentInput["name"] !== undefined &&
             typeof componentInput["name"] !== "string") {
-            throw new ValidationError("name must be a string", "name");
+            throw new api_errors_1.ValidationError("name must be a string", "name");
         }
     }
 }
+exports.UmlComponentValidator = UmlComponentValidator;
 /**
  * Validator for UML package elements.
  */
-export class UmlPackageValidator extends BaseUmlValidator {
+class UmlPackageValidator extends BaseUmlValidator {
     elementType = "uml-package";
     validateSpecific(input) {
         const packageInput = input;
         if (packageInput["name"] !== undefined &&
             typeof packageInput["name"] !== "string") {
-            throw new ValidationError("name must be a string", "name");
+            throw new api_errors_1.ValidationError("name must be a string", "name");
         }
     }
 }
+exports.UmlPackageValidator = UmlPackageValidator;
 /**
  * Validator for UML artifact elements.
  */
-export class UmlArtifactValidator extends BaseUmlValidator {
+class UmlArtifactValidator extends BaseUmlValidator {
     elementType = "uml-artifact";
     validateSpecific(input) {
         const artifactInput = input;
         if (artifactInput["name"] !== undefined &&
             typeof artifactInput["name"] !== "string") {
-            throw new ValidationError("name must be a string", "name");
+            throw new api_errors_1.ValidationError("name must be a string", "name");
         }
     }
 }
+exports.UmlArtifactValidator = UmlArtifactValidator;
 /**
  * Validator for UML note elements.
  */
-export class UmlNoteValidator extends BaseUmlValidator {
+class UmlNoteValidator extends BaseUmlValidator {
     elementType = "uml-note";
     validateSpecific(input) {
         const noteInput = input;
         if (noteInput["text"] !== undefined &&
             typeof noteInput["text"] !== "string") {
-            throw new ValidationError("text must be a string", "text");
+            throw new api_errors_1.ValidationError("text must be a string", "text");
         }
     }
 }
+exports.UmlNoteValidator = UmlNoteValidator;

package/src/lib/validators/element-validator-registry.js

@@ -1,15 +1,18 @@
-import { ValidationError } from "../errors/api-errors";
-import { RectangleValidator } from "./element-type-validators/rectangle-validator";
-import { TextValidator } from "./element-type-validators/text-validator";
-import { ConnectorValidator } from "./element-type-validators/connector-validator";
-import { UmlClassValidator, UmlInterfaceValidator, UmlComponentValidator, UmlPackageValidator, UmlArtifactValidator, UmlNoteValidator } from "./element-type-validators/uml-validators";
-import { CustomShapeValidator } from "./element-type-validators/custom-shape-validator";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElementValidatorRegistry = void 0;
+const api_errors_1 = require("../errors/api-errors");
+const rectangle_validator_1 = require("./element-type-validators/rectangle-validator");
+const text_validator_1 = require("./element-type-validators/text-validator");
+const connector_validator_1 = require("./element-type-validators/connector-validator");
+const uml_validators_1 = require("./element-type-validators/uml-validators");
+const custom_shape_validator_1 = require("./element-type-validators/custom-shape-validator");
 /**
  * Registry for element type validators.
  * Implements Open/Closed principle - new validators can be registered
  * without modifying this class.
  */
-export class ElementValidatorRegistry {
+class ElementValidatorRegistry {
     validators = new Map();
     constructor() {
         // Register built-in validators
@@ -19,15 +22,15 @@ export class ElementValidatorRegistry {
      * Registers built-in validators for standard element types.
      */
     registerBuiltInValidators() {
-        this.register(new RectangleValidator());
-        this.register(new TextValidator());
-        this.register(new ConnectorValidator());
-        this.register(new UmlClassValidator());
-        this.register(new UmlInterfaceValidator());
-        this.register(new UmlComponentValidator());
-        this.register(new UmlPackageValidator());
-        this.register(new UmlArtifactValidator());
-        this.register(new UmlNoteValidator());
+        this.register(new rectangle_validator_1.RectangleValidator());
+        this.register(new text_validator_1.TextValidator());
+        this.register(new connector_validator_1.ConnectorValidator());
+        this.register(new uml_validators_1.UmlClassValidator());
+        this.register(new uml_validators_1.UmlInterfaceValidator());
+        this.register(new uml_validators_1.UmlComponentValidator());
+        this.register(new uml_validators_1.UmlPackageValidator());
+        this.register(new uml_validators_1.UmlArtifactValidator());
+        this.register(new uml_validators_1.UmlNoteValidator());
     }
     register(validator) {
         this.validators.set(validator.elementType, validator);
@@ -41,7 +44,7 @@ export class ElementValidatorRegistry {
         // Handle custom shapes - create validator on demand
         if (elementType.startsWith("custom:")) {
             const shapeId = elementType.substring(7); // Remove "custom:" prefix
-            const customValidator = new CustomShapeValidator(shapeId);
+            const customValidator = new custom_shape_validator_1.CustomShapeValidator(shapeId);
             // Cache for future use
             this.validators.set(elementType, customValidator);
             return customValidator;
@@ -51,8 +54,9 @@ export class ElementValidatorRegistry {
     validate(input) {
         const validator = this.getValidator(input.type);
         if (!validator) {
-            throw new ValidationError(`Unknown element type: ${input.type}`, "type");
+            throw new api_errors_1.ValidationError(`Unknown element type: ${input.type}`, "type");
         }
         validator.validate(input);
     }
 }
+exports.ElementValidatorRegistry = ElementValidatorRegistry;

package/src/lib/validators/node-validator.js

@@ -1,8 +1,11 @@
-import { ValidationError } from "../errors/api-errors";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeValidator = void 0;
+const api_errors_1 = require("../errors/api-errors");
 /**
  * Validator for node operations.
  */
-export class NodeValidator {
+class NodeValidator {
     /**
      * Validates input for node creation.
      * @param input The creation input to validate
@@ -10,20 +13,20 @@ export class NodeValidator {
      */
     validateCreate(input) {
         if (!input.title || typeof input.title !== "string") {
-            throw new ValidationError("title is required", "title");
+            throw new api_errors_1.ValidationError("title is required", "title");
         }
         if (input.title.trim().length === 0) {
-            throw new ValidationError("title cannot be empty", "title");
+            throw new api_errors_1.ValidationError("title cannot be empty", "title");
         }
         if (input.title.length > 200) {
-            throw new ValidationError("title must be 200 characters or less", "title");
+            throw new api_errors_1.ValidationError("title must be 200 characters or less", "title");
         }
         if (input.content !== undefined && typeof input.content !== "string") {
-            throw new ValidationError("content must be a string", "content");
+            throw new api_errors_1.ValidationError("content must be a string", "content");
         }
         if (input.parentNodeId !== undefined &&
             typeof input.parentNodeId !== "string") {
-            throw new ValidationError("parentNodeId must be a string", "parentNodeId");
+            throw new api_errors_1.ValidationError("parentNodeId must be a string", "parentNodeId");
         }
         this.validateCanvasDimensions(input.canvasWidth, input.canvasHeight);
         this.validateLevel(input.level);
@@ -36,17 +39,17 @@ export class NodeValidator {
     validateUpdate(input) {
         if (input.title !== undefined) {
             if (typeof input.title !== "string") {
-                throw new ValidationError("title must be a string", "title");
+                throw new api_errors_1.ValidationError("title must be a string", "title");
             }
             if (input.title.trim().length === 0) {
-                throw new ValidationError("title cannot be empty", "title");
+                throw new api_errors_1.ValidationError("title cannot be empty", "title");
             }
             if (input.title.length > 200) {
-                throw new ValidationError("title must be 200 characters or less", "title");
+                throw new api_errors_1.ValidationError("title must be 200 characters or less", "title");
             }
         }
         if (input.content !== undefined && typeof input.content !== "string") {
-            throw new ValidationError("content must be a string", "content");
+            throw new api_errors_1.ValidationError("content must be a string", "content");
         }
         this.validateCanvasDimensions(input.canvasWidth, input.canvasHeight);
     }
@@ -56,18 +59,18 @@ export class NodeValidator {
     validateCanvasDimensions(width, height) {
         if (width !== undefined) {
             if (typeof width !== "number" || isNaN(width)) {
-                throw new ValidationError("canvasWidth must be a valid number", "canvasWidth");
+                throw new api_errors_1.ValidationError("canvasWidth must be a valid number", "canvasWidth");
             }
             if (width < 100 || width > 10000) {
-                throw new ValidationError("canvasWidth must be between 100 and 10000", "canvasWidth");
+                throw new api_errors_1.ValidationError("canvasWidth must be between 100 and 10000", "canvasWidth");
             }
         }
         if (height !== undefined) {
             if (typeof height !== "number" || isNaN(height)) {
-                throw new ValidationError("canvasHeight must be a valid number", "canvasHeight");
+                throw new api_errors_1.ValidationError("canvasHeight must be a valid number", "canvasHeight");
             }
             if (height < 100 || height > 10000) {
-                throw new ValidationError("canvasHeight must be between 100 and 10000", "canvasHeight");
+                throw new api_errors_1.ValidationError("canvasHeight must be between 100 and 10000", "canvasHeight");
             }
         }
     }
@@ -78,13 +81,14 @@ export class NodeValidator {
         if (level === undefined)
             return;
         if (typeof level !== "number" || isNaN(level)) {
-            throw new ValidationError("level must be a valid number", "level");
+            throw new api_errors_1.ValidationError("level must be a valid number", "level");
         }
         if (level < 0) {
-            throw new ValidationError("level must be non-negative", "level");
+            throw new api_errors_1.ValidationError("level must be non-negative", "level");
         }
         if (!Number.isInteger(level)) {
-            throw new ValidationError("level must be an integer", "level");
+            throw new api_errors_1.ValidationError("level must be an integer", "level");
         }
     }
 }
+exports.NodeValidator = NodeValidator;