@twin.org/data-core 0.0.1-next.32 → 0.0.1-next.33

package/dist/cjs/index.cjs

@@ -49,7 +49,11 @@ const ValidationMode = {
     /**
      * Use either validation mode.
      */
-    Either: "either"
+    Either: "either",
+    /**
+     * Use both validation modes.
+     */
+    Both: "both"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -209,23 +213,30 @@ class DataTypeHelper {
      * @param dataType The data type to validate.
      * @param data The data to validate.
      * @param validationFailures The list of validation failures to add to.
-     * @param validationMode The validation mode to use, defaults to either.
+     * @param options Optional options for validation.
+     * @param options.failOnMissingType If true, will fail validation if the data type is missing, defaults to false.
+     * @param options.validationMode The validation mode to use, defaults to either.
      * @returns True if the data was valid.
      */
-    static async validate(propertyName, dataType, data, validationFailures, validationMode) {
+    static async validate(propertyName, dataType, data, validationFailures, options) {
+        let isValid = true;
         if (core.Is.stringValue(dataType)) {
             const handler = DataTypeHandlerFactory.getIfExists(dataType);
             if (handler) {
-                validationMode = validationMode ?? ValidationMode.Either;
+                const validationMode = options?.validationMode ?? ValidationMode.Either;
                 // If we have a validate function use that as it is more specific
                 // and will produce better error messages
+                let hasValidated = false;
                 if ((validationMode === ValidationMode.Validate ||
+                    validationMode === ValidationMode.Both ||
                     validationMode === ValidationMode.Either) &&
                     core.Is.function(handler.validate)) {
-                    return handler.validate(propertyName, data, validationFailures);
+                    isValid = await handler.validate(propertyName, data, validationFailures);
+                    hasValidated = true;
                 }
-                else if ((validationMode === ValidationMode.JsonSchema ||
-                    validationMode === ValidationMode.Either) &&
+                if ((validationMode === ValidationMode.JsonSchema ||
+                    (validationMode === ValidationMode.Either && !hasValidated) ||
+                    validationMode === ValidationMode.Both) &&
                     core.Is.function(handler.jsonSchema)) {
                     // Otherwise use the JSON schema if there is one
                     const schema = await handler.jsonSchema();
@@ -242,13 +253,25 @@ class DataTypeHelper {
                                 }
                             });
                         }
-                        return validationResult.result;
+                        if (!validationResult.result) {
+                            isValid = false;
+                        }
                     }
                 }
             }
+            else if (options?.failOnMissingType ?? false) {
+                // If we don't have a handler for a specific type and we are failing on missing type
+                validationFailures.push({
+                    property: propertyName,
+                    reason: "validation.schema.missingType",
+                    properties: {
+                        dataType
+                    }
+                });
+                isValid = false;
+            }
         }
-        // Return true by default if no other mechanism for validation is available
-        return true;
+        return isValid;
     }
 }
 

package/dist/esm/index.mjs

@@ -47,7 +47,11 @@ const ValidationMode = {
     /**
      * Use either validation mode.
      */
-    Either: "either"
+    Either: "either",
+    /**
+     * Use both validation modes.
+     */
+    Both: "both"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -207,23 +211,30 @@ class DataTypeHelper {
      * @param dataType The data type to validate.
      * @param data The data to validate.
      * @param validationFailures The list of validation failures to add to.
-     * @param validationMode The validation mode to use, defaults to either.
+     * @param options Optional options for validation.
+     * @param options.failOnMissingType If true, will fail validation if the data type is missing, defaults to false.
+     * @param options.validationMode The validation mode to use, defaults to either.
      * @returns True if the data was valid.
      */
-    static async validate(propertyName, dataType, data, validationFailures, validationMode) {
+    static async validate(propertyName, dataType, data, validationFailures, options) {
+        let isValid = true;
         if (Is.stringValue(dataType)) {
             const handler = DataTypeHandlerFactory.getIfExists(dataType);
             if (handler) {
-                validationMode = validationMode ?? ValidationMode.Either;
+                const validationMode = options?.validationMode ?? ValidationMode.Either;
                 // If we have a validate function use that as it is more specific
                 // and will produce better error messages
+                let hasValidated = false;
                 if ((validationMode === ValidationMode.Validate ||
+                    validationMode === ValidationMode.Both ||
                     validationMode === ValidationMode.Either) &&
                     Is.function(handler.validate)) {
-                    return handler.validate(propertyName, data, validationFailures);
+                    isValid = await handler.validate(propertyName, data, validationFailures);
+                    hasValidated = true;
                 }
-                else if ((validationMode === ValidationMode.JsonSchema ||
-                    validationMode === ValidationMode.Either) &&
+                if ((validationMode === ValidationMode.JsonSchema ||
+                    (validationMode === ValidationMode.Either && !hasValidated) ||
+                    validationMode === ValidationMode.Both) &&
                     Is.function(handler.jsonSchema)) {
                     // Otherwise use the JSON schema if there is one
                     const schema = await handler.jsonSchema();
@@ -240,13 +251,25 @@ class DataTypeHelper {
                                 }
                             });
                         }
-                        return validationResult.result;
+                        if (!validationResult.result) {
+                            isValid = false;
+                        }
                     }
                 }
             }
+            else if (options?.failOnMissingType ?? false) {
+                // If we don't have a handler for a specific type and we are failing on missing type
+                validationFailures.push({
+                    property: propertyName,
+                    reason: "validation.schema.missingType",
+                    properties: {
+                        dataType
+                    }
+                });
+                isValid = false;
+            }
         }
-        // Return true by default if no other mechanism for validation is available
-        return true;
+        return isValid;
     }
 }
 

package/dist/types/models/validationMode.d.ts

@@ -14,6 +14,10 @@ export declare const ValidationMode: {
      * Use either validation mode.
      */
     readonly Either: "either";
+    /**
+     * Use both validation modes.
+     */
+    readonly Both: "both";
 };
 /**
  * Validation modes for validating data types.

package/dist/types/utils/dataTypeHelper.d.ts

@@ -10,8 +10,13 @@ export declare class DataTypeHelper {
      * @param dataType The data type to validate.
      * @param data The data to validate.
      * @param validationFailures The list of validation failures to add to.
-     * @param validationMode The validation mode to use, defaults to either.
+     * @param options Optional options for validation.
+     * @param options.failOnMissingType If true, will fail validation if the data type is missing, defaults to false.
+     * @param options.validationMode The validation mode to use, defaults to either.
      * @returns True if the data was valid.
      */
-    static validate(propertyName: string, dataType: string | undefined, data: unknown, validationFailures: IValidationFailure[], validationMode?: ValidationMode): Promise<boolean>;
+    static validate(propertyName: string, dataType: string | undefined, data: unknown, validationFailures: IValidationFailure[], options?: {
+        validationMode?: ValidationMode;
+        failOnMissingType?: boolean;
+    }): Promise<boolean>;
 }

package/docs/changelog.md

@@ -1,5 +1,17 @@
 # @twin.org/data-core - Changelog
 
+## [0.0.1-next.33](https://github.com/twinfoundation/data/compare/data-core-v0.0.1-next.32...data-core-v0.0.1-next.33) (2025-06-02)
+
+
+### Features
+
+* add fail on missing type option and both mode ([e8b9702](https://github.com/twinfoundation/data/commit/e8b97029a04b646497ff0e55b9610291e58ae92a))
+
+
+### Bug Fixes
+
+* tests using context ([577b3bb](https://github.com/twinfoundation/data/commit/577b3bbb661eafbf6d3fd157133c106732e8eb3d))
+
 ## [0.0.1-next.32](https://github.com/twinfoundation/data/compare/data-core-v0.0.1-next.31...data-core-v0.0.1-next.32) (2025-05-28)
 
 

package/docs/reference/classes/DataTypeHelper.md

@@ -16,7 +16,7 @@ Class to help with data types.
 
 ### validate()
 
-> `static` **validate**(`propertyName`, `dataType`, `data`, `validationFailures`, `validationMode?`): `Promise`\<`boolean`\>
+> `static` **validate**(`propertyName`, `dataType`, `data`, `validationFailures`, `options?`): `Promise`\<`boolean`\>
 
 Validate a data type.
 
@@ -46,12 +46,22 @@ The data to validate.
 
 The list of validation failures to add to.
 
-##### validationMode?
+##### options?
+
+Optional options for validation.
+
+###### validationMode?
 
 [`ValidationMode`](../type-aliases/ValidationMode.md)
 
 The validation mode to use, defaults to either.
 
+###### failOnMissingType?
+
+`boolean`
+
+If true, will fail validation if the data type is missing, defaults to false.
+
 #### Returns
 
 `Promise`\<`boolean`\>

package/docs/reference/variables/ValidationMode.md

@@ -23,3 +23,9 @@ Use the JSON Schema methods of the data type.
 > `readonly` **Either**: `"either"` = `"either"`
 
 Use either validation mode.
+
+### Both
+
+> `readonly` **Both**: `"both"` = `"both"`
+
+Use both validation modes.

package/locales/en.json

@@ -5,7 +5,8 @@
 				"keyAlreadyExists": "The key already exists"
 			},
 			"schema": {
-				"failedValidation": "The JSON schema failed validation, {message}"
+				"failedValidation": "The JSON schema failed validation, {message}",
+				"missingType": "Failed to validate as there is no handler for type \"{dataType}\""
 			}
 		}
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@twin.org/data-core",
-	"version": "0.0.1-next.32",
+	"version": "0.0.1-next.33",
 	"description": "Definitions and helpers for using with data and schemas",
 	"repository": {
 		"type": "git",