@kravc/schema 2.7.5 → 2.8.0-alpha.0

package/dist/helpers/normalizeAttributes.js

@@ -0,0 +1,243 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const normalizeType_1 = __importDefault(require("./normalizeType"));
+const mapObjectProperties_1 = __importDefault(require("./mapObjectProperties"));
+/**
+ * Normalizes object attribute values based on a JSON Schema definition.
+ *
+ * ## Intent
+ *
+ * This function ensures that object properties conform to their schema definitions by:
+ * 1. Setting default values for properties that are undefined (but not null)
+ * 2. Normalizing existing values to match their schema-defined types (e.g., converting
+ *    string "123" to number 123, or string "true" to boolean true)
+ *
+ * The function operates recursively, processing nested objects, arrays, and referenced
+ * schemas ($ref) to ensure all properties throughout the object tree are normalized
+ * according to their respective schema definitions.
+ *
+ * This is particularly useful in data processing pipelines where data may come from
+ * external sources (forms, APIs, databases) with inconsistent types, but needs to be
+ * normalized before validation or further processing.
+ *
+ * ## Use Cases
+ *
+ * 1. **Form data processing**: HTML forms submit all values as strings. This function
+ *    converts them to their expected types (numbers, booleans) based on schema definitions
+ *    and fills in default values for missing fields.
+ *
+ * 2. **API response normalization**: When consuming APIs that return loosely-typed data
+ *    (e.g., numbers as strings, booleans as strings), this function ensures values match
+ *    the expected schema types before validation or business logic processing.
+ *
+ * 3. **Configuration object initialization**: Setting default values and normalizing types
+ *    for configuration objects based on their schema definitions, ensuring consistent
+ *    structure and types throughout the application.
+ *
+ * 4. **Data migration and transformation**: Normalizing data structures during migration
+ *    or transformation processes where source data may have inconsistent types but target
+ *    schema requires specific types.
+ *
+ * 5. **Pre-validation normalization**: Preparing objects for schema validation by ensuring
+ *    types are correct and defaults are applied, reducing validation errors and improving
+ *    data quality.
+ *
+ * ## Behavior
+ *
+ * - **Default values**: Properties that are `undefined` will be set to their schema-defined
+ *   default value (if one exists). Properties that are `null` are left as `null` and will
+ *   not receive default values. Default values are also normalized according to their type
+ *   (e.g., a default string "123" with type "number" will be converted to the number 123).
+ *
+ * - **Type normalization**: Properties with existing values (including default values that
+ *   were just set) are normalized to match their schema type using `normalizeType`. This
+ *   includes converting strings to numbers/booleans where appropriate, while preserving the
+ *   original value if conversion is not possible.
+ *
+ * - **Recursive processing**: The function processes nested objects, arrays, and schema
+ *   references ($ref) recursively, ensuring all nested properties are normalized.
+ *
+ * - **Non-destructive**: The function mutates the input object in place. If you need to
+ *   preserve the original, create a deep copy before calling this function.
+ *
+ * ## Examples
+ *
+ * ### Basic Usage: Default Values and Type Normalization
+ * ```typescript
+ * import Schema from './Schema';
+ * import normalizeAttributes from './normalizeAttributes';
+ *
+ * const schema = new Schema({
+ *   name: { type: 'string', default: 'Anonymous' },
+ *   age: { type: 'number' },
+ *   isActive: { type: 'boolean', default: false }
+ * }, 'user-schema');
+ *
+ * const user = {
+ *   age: '25'  // string that should be a number
+ * };
+ *
+ * normalizeAttributes(user, schema.jsonSchema, {});
+ *
+ * // Result:
+ * // {
+ * //   name: 'Anonymous',      // default value applied
+ * //   age: 25,                // string converted to number
+ * //   isActive: false         // default value applied
+ * // }
+ * ```
+ *
+ * ### Nested Objects
+ * ```typescript
+ * const schema = new Schema({
+ *   address: {
+ *     type: 'object',
+ *     properties: {
+ *       street: { type: 'string', default: 'Unknown' },
+ *       zipCode: { type: 'number' }
+ *     }
+ *   }
+ * }, 'profile-schema');
+ *
+ * const profile = {
+ *   address: {
+ *     zipCode: '12345'  // string that should be a number
+ *   }
+ * };
+ *
+ * normalizeAttributes(profile, schema.jsonSchema, {});
+ *
+ * // Result:
+ * // {
+ * //   address: {
+ * //     street: 'Unknown',  // default value applied
+ * //     zipCode: 12345      // string converted to number
+ * //   }
+ * // }
+ * ```
+ *
+ * ### Arrays with Schema References
+ * ```typescript
+ * const itemSchema = new Schema({
+ *   id: { type: 'number' },
+ *   name: { type: 'string', default: 'Unnamed' }
+ * }, 'item-schema');
+ *
+ * const schema = new Schema({
+ *   items: {
+ *     type: 'array',
+ *     items: { $ref: 'item-schema' }
+ *   }
+ * }, 'collection-schema');
+ *
+ * const collection = {
+ *   items: [
+ *     { id: '1' },           // id is a string, should be number
+ *     { id: '2', name: 'Item 2' }
+ *   ]
+ * };
+ *
+ * const schemasMap = {
+ *   'item-schema': itemSchema.jsonSchema
+ * };
+ *
+ * normalizeAttributes(collection, schema.jsonSchema, schemasMap);
+ *
+ * // Result:
+ * // {
+ * //   items: [
+ * //     { id: 1, name: 'Unnamed' },  // id normalized, default name applied
+ * //     { id: 2, name: 'Item 2' }    // id normalized, existing name preserved
+ * //   ]
+ * // }
+ * ```
+ *
+ * ### Boolean Normalization
+ * ```typescript
+ * const schema = new Schema({
+ *   enabled: { type: 'boolean', default: false },
+ *   verified: { type: 'boolean' }
+ * }, 'settings-schema');
+ *
+ * const settings = {
+ *   verified: 'yes'  // string that should be boolean
+ * };
+ *
+ * normalizeAttributes(settings, schema.jsonSchema, {});
+ *
+ * // Result:
+ * // {
+ * //   enabled: false,   // default value applied
+ * //   verified: true    // string "yes" converted to boolean true
+ * // }
+ * ```
+ *
+ * ### Handling Null Values
+ * ```typescript
+ * const schema = new Schema({
+ *   optionalField: { type: 'string', default: 'default-value' }
+ * }, 'test-schema');
+ *
+ * const obj1 = {};                    // undefined → default applied
+ * const obj2 = { optionalField: null }; // null → no default applied
+ *
+ * normalizeAttributes(obj1, schema.jsonSchema, {});
+ * normalizeAttributes(obj2, schema.jsonSchema, {});
+ *
+ * // obj1: { optionalField: 'default-value' }
+ * // obj2: { optionalField: null }  // null preserved, default not applied
+ * ```
+ *
+ * ### Default Value Normalization
+ * ```typescript
+ * const schema = new Schema({
+ *   count: { type: 'number', default: '42' },      // default is string, type is number
+ *   enabled: { type: 'boolean', default: 'true' }   // default is string, type is boolean
+ * }, 'config-schema');
+ *
+ * const config = {};
+ *
+ * normalizeAttributes(config, schema.jsonSchema, {});
+ *
+ * // Result:
+ * // {
+ * //   count: 42,      // default string "42" normalized to number
+ * //   enabled: true   // default string "true" normalized to boolean
+ * // }
+ * ```
+ *
+ * @param object - The target object to normalize (mutated in place)
+ * @param jsonSchema - The JSON Schema definition describing the object structure
+ * @param jsonSchemasMap - Map of schema IDs to schema definitions, used for resolving $ref references
+ * @returns void (mutates the input object)
+ */
+const normalizeAttributes = (object, jsonSchema, jsonSchemasMap) => {
+    /** Callback to normalize value based on property type defined in schema */
+    const callback = (propertyName, propertySchema, object) => {
+        let value = object[propertyName];
+        const type = (0, lodash_1.get)(propertySchema, 'type');
+        const defaultValue = (0, lodash_1.get)(propertySchema, 'default');
+        const hasValue = !(0, lodash_1.isUndefined)(value);
+        const hasDefaultValue = !(0, lodash_1.isUndefined)(defaultValue);
+        const shouldSetDefaultValue = hasDefaultValue && !hasValue;
+        // Set default value if property is undefined and default exists
+        if (shouldSetDefaultValue) {
+            object[propertyName] = defaultValue;
+            value = defaultValue; // Update value reference for normalization
+        }
+        const hasType = !!type;
+        const hasValueAfterDefault = !(0, lodash_1.isUndefined)(value);
+        const shouldNormalizeValue = hasType && hasValueAfterDefault;
+        // Normalize the current value (original or default) if type is defined
+        if (shouldNormalizeValue) {
+            object[propertyName] = (0, normalizeType_1.default)(type, value);
+        }
+    };
+    (0, mapObjectProperties_1.default)(object, jsonSchema, jsonSchemasMap, callback);
+};
+exports.default = normalizeAttributes;
+//# sourceMappingURL=normalizeAttributes.js.map

package/dist/helpers/normalizeAttributes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeAttributes.js","sourceRoot":"","sources":["../../src/helpers/normalizeAttributes.ts"],"names":[],"mappings":";;;;;AAAA,mCAA0C;AAE1C,oEAA4C;AAC5C,gFAAwD;AAGxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgNG;AACH,MAAM,mBAAmB,GAAG,CAAC,MAAoB,EAAE,UAAsB,EAAE,cAA8B,EAAE,EAAE;IAC3G,2EAA2E;IAC3E,MAAM,QAAQ,GAAG,CAAC,YAAoB,EAAE,cAA8B,EAAE,MAAoB,EAAE,EAAE;QAC9F,IAAI,KAAK,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;QAEjC,MAAM,IAAI,GAAG,IAAA,YAAG,EAAC,cAAc,EAAE,MAAM,CAAC,CAAC;QACzC,MAAM,YAAY,GAAG,IAAA,YAAG,EAAC,cAAc,EAAE,SAAS,CAAC,CAAC;QAEpD,MAAM,QAAQ,GAAG,CAAC,IAAA,oBAAW,EAAC,KAAK,CAAC,CAAC;QACrC,MAAM,eAAe,GAAG,CAAC,IAAA,oBAAW,EAAC,YAAY,CAAC,CAAC;QACnD,MAAM,qBAAqB,GAAG,eAAe,IAAI,CAAC,QAAQ,CAAC;QAE3D,gEAAgE;QAChE,IAAI,qBAAqB,EAAE,CAAC;YAC1B,MAAM,CAAC,YAAY,CAAC,GAAG,YAAY,CAAC;YACpC,KAAK,GAAG,YAAY,CAAC,CAAC,2CAA2C;QACnE,CAAC;QAED,MAAM,OAAO,GAAG,CAAC,CAAC,IAAI,CAAC;QACvB,MAAM,oBAAoB,GAAG,CAAC,IAAA,oBAAW,EAAC,KAAK,CAAC,CAAC;QACjD,MAAM,oBAAoB,GAAG,OAAO,IAAI,oBAAoB,CAAC;QAE7D,uEAAuE;QACvE,IAAI,oBAAoB,EAAE,CAAC;YACzB,MAAM,CAAC,YAAY,CAAC,GAAG,IAAA,uBAAa,EAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QACpD,CAAC;IACH,CAAC,CAAC;IAEF,IAAA,6BAAmB,EAAC,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,QAAQ,CAAC,CAAC;AACpE,CAAC,CAAC;AAEF,kBAAe,mBAAmB,CAAC"}

package/dist/helpers/normalizeProperties.d.ts

@@ -0,0 +1,168 @@
+import type { EnumSchema, PropertiesSchema } from './JsonSchema';
+/**
+ * Normalizes JSON schema properties by ensuring all properties have an explicit `type` attribute.
+ *
+ * **Intent:**
+ * This function transforms schemas that may have implicit or missing type information into
+ * fully normalized schemas with explicit types. It recursively processes nested structures
+ * (objects and arrays) to ensure type consistency throughout the schema hierarchy.
+ *
+ * **Use Cases:**
+ * - **Schema Validation Preparation**: Ensures schemas are ready for validation where type
+ *   information is required by validators or processing tools
+ * - **External Schema Normalization**: Normalizes schemas imported from external sources
+ *   (e.g., OpenAPI specs, YAML schemas) that may omit type information
+ * - **Type Inference**: Automatically infers types from structural hints (e.g., presence of
+ *   `properties` implies `object`, presence of `items` implies `array`)
+ * - **Schema Consistency**: Guarantees consistent schema structure before further processing
+ *   or transformation
+ * - **Default Type Assignment**: Provides sensible defaults (e.g., `string` for primitives)
+ *   when type cannot be inferred
+ *
+ * **Behavior:**
+ * - **Enum Schemas**: Sets `type` to `'string'` if missing (preserves existing type if present)
+ * - **Reference Properties**: Skips `$ref` properties (they don't need type normalization)
+ * - **Type Inference Priority** (when type is missing):
+ *   1. If property has `properties` → sets `type: 'object'`
+ *   2. Else if property has `items` → sets `type: 'array'`
+ *   3. Else → sets `type: 'string'` (default)
+ * - **Object Properties**:
+ *   - Infers `type: 'object'` from presence of `properties` (if type not already set)
+ *   - Creates empty `properties: {}` if `type: 'object'` but no properties exist
+ *   - Recursively normalizes nested object properties
+ *   - Note: If both `properties` and `items` exist, `properties` takes precedence
+ * - **Array Properties**:
+ *   - Infers `type: 'array'` from presence of `items` (if type not already set)
+ *   - Sets default `items: { type: 'string' }` if array has no items
+ *   - Normalizes item schemas: sets `type: 'object'` if items have `properties` (not undefined)
+ *     - `properties: null` → treated as having properties (sets type to 'object')
+ *     - `properties: undefined` → treated as not having properties (no type set)
+ *     - Empty object `{}` → treated as not having properties (no type set)
+ *   - Recursively normalizes nested properties within array items
+ * - **Primitive Properties**: Sets `type: 'string'` as default when no type, items, or properties exist
+ * - **Existing Types**: Never overrides existing type values (even if structure suggests different type)
+ * - **Edge Cases**:
+ *   - Empty schemas (`{}`) are handled gracefully
+ *   - Properties with conflicting structure (e.g., `type: 'object'` with `items`) are normalized
+ *     according to the explicit type, ignoring conflicting structural hints
+ *
+ * **Examples:**
+ *
+ * @example Enum schema normalization
+ * ```typescript
+ * const schema: EnumSchema = { enum: ['red', 'green', 'blue'] };
+ * normalizeProperties(schema);
+ * // Result: { enum: ['red', 'green', 'blue'], type: 'string' }
+ * ```
+ *
+ * @example Object type inference
+ * ```typescript
+ * const schema: PropertiesSchema = {
+ *   user: {
+ *     properties: {
+ *       name: {}
+ *     }
+ *   }
+ * };
+ * normalizeProperties(schema);
+ * // Result:
+ * // {
+ * //   user: {
+ * //     type: 'object',
+ * //     properties: {
+ * //       name: { type: 'string' }
+ * //     }
+ * //   }
+ * // }
+ * ```
+ *
+ * @example Array type inference
+ * ```typescript
+ * const schema: PropertiesSchema = {
+ *   tags: {
+ *     items: { type: 'string' }
+ *   }
+ * };
+ * normalizeProperties(schema);
+ * // Result:
+ * // {
+ * //   tags: {
+ * //     type: 'array',
+ * //     items: { type: 'string' }
+ * //   }
+ * // }
+ * ```
+ *
+ * @example Complex nested structure
+ * ```typescript
+ * const schema: PropertiesSchema = {
+ *   profile: {
+ *     properties: {
+ *       name: {},
+ *       addresses: {
+ *         items: {
+ *           properties: {
+ *             street: {},
+ *             city: {}
+ *           }
+ *         }
+ *       }
+ *     }
+ *   }
+ * };
+ * normalizeProperties(schema);
+ * // Result:
+ * // {
+ * //   profile: {
+ * //     type: 'object',
+ * //     properties: {
+ * //       name: { type: 'string' },
+ * //       addresses: {
+ * //         type: 'array',
+ * //         items: {
+ * //           type: 'object',
+ * //           properties: {
+ * //             street: { type: 'string' },
+ * //             city: { type: 'string' }
+ * //           }
+ * //         }
+ * //       }
+ * //     }
+ * //   }
+ * // }
+ * ```
+ *
+ * @example Reference properties are skipped
+ * ```typescript
+ * const schema: PropertiesSchema = {
+ *   refField: { $ref: '#/definitions/User' },
+ *   normalField: {}
+ * };
+ * normalizeProperties(schema);
+ * // Result:
+ * // {
+ * //   refField: { $ref: '#/definitions/User' }, // Unchanged
+ * //   normalField: { type: 'string' }
+ * // }
+ * ```
+ *
+ * @example Default type assignment
+ * ```typescript
+ * const schema: PropertiesSchema = {
+ *   title: {},
+ *   count: { type: 'number' }
+ * };
+ * normalizeProperties(schema);
+ * // Result:
+ * // {
+ * //   title: { type: 'string' }, // Default assigned
+ * //   count: { type: 'number' }  // Existing preserved
+ * // }
+ * ```
+ *
+ * @param schema - The schema to normalize (either an EnumSchema or PropertiesSchema)
+ * @modifies The schema object is mutated in place with normalized types
+ */
+declare const normalizeProperties: (schema: EnumSchema | PropertiesSchema) => void;
+export default normalizeProperties;
+//# sourceMappingURL=normalizeProperties.d.ts.map

package/dist/helpers/normalizeProperties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeProperties.d.ts","sourceRoot":"","sources":["../../src/helpers/normalizeProperties.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAIjB,MAAM,cAAc,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmKG;AACH,QAAA,MAAM,mBAAmB,GAAI,QAAQ,UAAU,GAAG,gBAAgB,SAwEjE,CAAC;AAEF,eAAe,mBAAmB,CAAC"}

package/dist/helpers/normalizeProperties.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+/**
+ * Normalizes JSON schema properties by ensuring all properties have an explicit `type` attribute.
+ *
+ * **Intent:**
+ * This function transforms schemas that may have implicit or missing type information into
+ * fully normalized schemas with explicit types. It recursively processes nested structures
+ * (objects and arrays) to ensure type consistency throughout the schema hierarchy.
+ *
+ * **Use Cases:**
+ * - **Schema Validation Preparation**: Ensures schemas are ready for validation where type
+ *   information is required by validators or processing tools
+ * - **External Schema Normalization**: Normalizes schemas imported from external sources
+ *   (e.g., OpenAPI specs, YAML schemas) that may omit type information
+ * - **Type Inference**: Automatically infers types from structural hints (e.g., presence of
+ *   `properties` implies `object`, presence of `items` implies `array`)
+ * - **Schema Consistency**: Guarantees consistent schema structure before further processing
+ *   or transformation
+ * - **Default Type Assignment**: Provides sensible defaults (e.g., `string` for primitives)
+ *   when type cannot be inferred
+ *
+ * **Behavior:**
+ * - **Enum Schemas**: Sets `type` to `'string'` if missing (preserves existing type if present)
+ * - **Reference Properties**: Skips `$ref` properties (they don't need type normalization)
+ * - **Type Inference Priority** (when type is missing):
+ *   1. If property has `properties` → sets `type: 'object'`
+ *   2. Else if property has `items` → sets `type: 'array'`
+ *   3. Else → sets `type: 'string'` (default)
+ * - **Object Properties**:
+ *   - Infers `type: 'object'` from presence of `properties` (if type not already set)
+ *   - Creates empty `properties: {}` if `type: 'object'` but no properties exist
+ *   - Recursively normalizes nested object properties
+ *   - Note: If both `properties` and `items` exist, `properties` takes precedence
+ * - **Array Properties**:
+ *   - Infers `type: 'array'` from presence of `items` (if type not already set)
+ *   - Sets default `items: { type: 'string' }` if array has no items
+ *   - Normalizes item schemas: sets `type: 'object'` if items have `properties` (not undefined)
+ *     - `properties: null` → treated as having properties (sets type to 'object')
+ *     - `properties: undefined` → treated as not having properties (no type set)
+ *     - Empty object `{}` → treated as not having properties (no type set)
+ *   - Recursively normalizes nested properties within array items
+ * - **Primitive Properties**: Sets `type: 'string'` as default when no type, items, or properties exist
+ * - **Existing Types**: Never overrides existing type values (even if structure suggests different type)
+ * - **Edge Cases**:
+ *   - Empty schemas (`{}`) are handled gracefully
+ *   - Properties with conflicting structure (e.g., `type: 'object'` with `items`) are normalized
+ *     according to the explicit type, ignoring conflicting structural hints
+ *
+ * **Examples:**
+ *
+ * @example Enum schema normalization
+ * ```typescript
+ * const schema: EnumSchema = { enum: ['red', 'green', 'blue'] };
+ * normalizeProperties(schema);
+ * // Result: { enum: ['red', 'green', 'blue'], type: 'string' }
+ * ```
+ *
+ * @example Object type inference
+ * ```typescript
+ * const schema: PropertiesSchema = {
+ *   user: {
+ *     properties: {
+ *       name: {}
+ *     }
+ *   }
+ * };
+ * normalizeProperties(schema);
+ * // Result:
+ * // {
+ * //   user: {
+ * //     type: 'object',
+ * //     properties: {
+ * //       name: { type: 'string' }
+ * //     }
+ * //   }
+ * // }
+ * ```
+ *
+ * @example Array type inference
+ * ```typescript
+ * const schema: PropertiesSchema = {
+ *   tags: {
+ *     items: { type: 'string' }
+ *   }
+ * };
+ * normalizeProperties(schema);
+ * // Result:
+ * // {
+ * //   tags: {
+ * //     type: 'array',
+ * //     items: { type: 'string' }
+ * //   }
+ * // }
+ * ```
+ *
+ * @example Complex nested structure
+ * ```typescript
+ * const schema: PropertiesSchema = {
+ *   profile: {
+ *     properties: {
+ *       name: {},
+ *       addresses: {
+ *         items: {
+ *           properties: {
+ *             street: {},
+ *             city: {}
+ *           }
+ *         }
+ *       }
+ *     }
+ *   }
+ * };
+ * normalizeProperties(schema);
+ * // Result:
+ * // {
+ * //   profile: {
+ * //     type: 'object',
+ * //     properties: {
+ * //       name: { type: 'string' },
+ * //       addresses: {
+ * //         type: 'array',
+ * //         items: {
+ * //           type: 'object',
+ * //           properties: {
+ * //             street: { type: 'string' },
+ * //             city: { type: 'string' }
+ * //           }
+ * //         }
+ * //       }
+ * //     }
+ * //   }
+ * // }
+ * ```
+ *
+ * @example Reference properties are skipped
+ * ```typescript
+ * const schema: PropertiesSchema = {
+ *   refField: { $ref: '#/definitions/User' },
+ *   normalField: {}
+ * };
+ * normalizeProperties(schema);
+ * // Result:
+ * // {
+ * //   refField: { $ref: '#/definitions/User' }, // Unchanged
+ * //   normalField: { type: 'string' }
+ * // }
+ * ```
+ *
+ * @example Default type assignment
+ * ```typescript
+ * const schema: PropertiesSchema = {
+ *   title: {},
+ *   count: { type: 'number' }
+ * };
+ * normalizeProperties(schema);
+ * // Result:
+ * // {
+ * //   title: { type: 'string' }, // Default assigned
+ * //   count: { type: 'number' }  // Existing preserved
+ * // }
+ * ```
+ *
+ * @param schema - The schema to normalize (either an EnumSchema or PropertiesSchema)
+ * @modifies The schema object is mutated in place with normalized types
+ */
+const normalizeProperties = (schema) => {
+    const { enum: isEnum } = schema;
+    if (isEnum) {
+        const enumSchema = schema;
+        enumSchema.type = enumSchema.type || 'string';
+        return;
+    }
+    const properties = schema;
+    for (const name in properties) {
+        const property = properties[name];
+        const { $ref: isRef } = property;
+        if (isRef) {
+            continue;
+        }
+        const hasType = !!(0, lodash_1.get)(property, 'type');
+        const hasItems = !!(0, lodash_1.get)(property, 'items');
+        const hasProperties = !!(0, lodash_1.get)(property, 'properties');
+        if (!hasType) {
+            if (hasProperties) {
+                (0, lodash_1.set)(property, 'type', 'object');
+            }
+            else if (hasItems) {
+                (0, lodash_1.set)(property, 'type', 'array');
+            }
+            else {
+                (0, lodash_1.set)(property, 'type', 'string');
+            }
+        }
+        const type = (0, lodash_1.get)(property, 'type');
+        const isObject = type === 'object';
+        if (isObject) {
+            if (!hasProperties) {
+                property.properties = {};
+            }
+            // istanbul ignore next - unreachable defensive code: properties is always set to {} above if missing
+            normalizeProperties(property.properties || {});
+        }
+        const isArray = type === 'array';
+        if (isArray) {
+            if (hasItems) {
+                // istanbul ignore next - unreachable defensive code: if items is undefined, hasItems would be false
+                const { items = {} } = property;
+                const isItemObject = !(0, lodash_1.isUndefined)(items.properties);
+                if (isItemObject) {
+                    (0, lodash_1.set)(items, 'type', 'object');
+                    normalizeProperties(items.properties || {});
+                }
+            }
+            else {
+                property.items = { type: 'string' };
+            }
+        }
+    }
+};
+exports.default = normalizeProperties;
+//# sourceMappingURL=normalizeProperties.js.map

package/dist/helpers/normalizeProperties.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeProperties.js","sourceRoot":"","sources":["../../src/helpers/normalizeProperties.ts"],"names":[],"mappings":";;AAAA,mCAA+C;AAU/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmKG;AACH,MAAM,mBAAmB,GAAG,CAAC,MAAqC,EAAE,EAAE;IACpE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAI,MAAqB,CAAC;IAEhD,IAAI,MAAM,EAAE,CAAC;QACX,MAAM,UAAU,GAAI,MAAqB,CAAC;QAC1C,UAAU,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,IAAI,QAAQ,CAAC;QAE9C,OAAO;IACT,CAAC;IAED,MAAM,UAAU,GAAI,MAA2B,CAAC;IAEhD,KAAK,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC;QAC9B,MAAM,QAAQ,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;QAElC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAI,QAAoC,CAAC;QAE9D,IAAI,KAAK,EAAE,CAAC;YACV,SAAS;QACX,CAAC;QAED,MAAM,OAAO,GAAG,CAAC,CAAC,IAAA,YAAG,EAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QACxC,MAAM,QAAQ,GAAG,CAAC,CAAC,IAAA,YAAG,EAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QAC1C,MAAM,aAAa,GAAG,CAAC,CAAC,IAAA,YAAG,EAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;QAEpD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,IAAI,aAAa,EAAE,CAAC;gBAClB,IAAA,YAAG,EAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;YAElC,CAAC;iBAAM,IAAI,QAAQ,EAAE,CAAC;gBACpB,IAAA,YAAG,EAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;YAEjC,CAAC;iBAAM,CAAC;gBACN,IAAA,YAAG,EAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;YAElC,CAAC;QACH,CAAC;QAED,MAAM,IAAI,GAAG,IAAA,YAAG,EAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAEnC,MAAM,QAAQ,GAAG,IAAI,KAAK,QAAQ,CAAC;QAEnC,IAAI,QAAQ,EAAE,CAAC;YACb,IAAI,CAAC,aAAa,EAAE,CAAC;gBAClB,QAAiC,CAAC,UAAU,GAAG,EAAE,CAAC;YACrD,CAAC;YAED,qGAAqG;YACrG,mBAAmB,CAAE,QAAiC,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC;QAC3E,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,KAAK,OAAO,CAAC;QAEjC,IAAI,OAAO,EAAE,CAAC;YACZ,IAAI,QAAQ,EAAE,CAAC;gBACb,oGAAoG;gBACpG,MAAM,EAAE,KAAK,GAAG,EAAE,EAAE,GAAI,QAAgC,CAAC;gBAEzD,MAAM,YAAY,GAAG,CAAC,IAAA,oBAAW,EAAE,KAA8B,CAAC,UAAU,CAAC,CAAC;gBAE9E,IAAI,YAAY,EAAE,CAAC;oBACjB,IAAA,YAAG,EAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;oBAE7B,mBAAmB,CAAE,KAA8B,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC;gBACxE,CAAC;YAEH,CAAC;iBAAM,CAAC;gBACL,QAAgC,CAAC,KAAK,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;YAE/D,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC,CAAC;AAEF,kBAAe,mBAAmB,CAAC"}