@c7-digital/ledger 0.0.6 → 0.0.7

package/lib/src/generated/asyncapi-schema.js

@@ -1,5 +1,5 @@
 // Auto-generated file - do not edit manually
-// Generated from /Users/stefanpla/Development/c7/sandbox/stream_interfaces/c7_ledger/ledger/specs/asyncapi_3.4.7.yaml
+// Generated from /Users/stefanpla/Development/c7/c7_ledger/c7_ledger/ledger/specs/asyncapi_3.4.7.yaml
 export const ASYNCAPI_SCHEMA = `asyncapi: 2.6.0
 info:
   title: JSON Ledger API WebSocket endpoints

package/lib/src/generated/openapi-schema.js

@@ -1,5 +1,5 @@
 // Auto-generated file - do not edit manually
-// Generated from /Users/stefanpla/Development/c7/sandbox/stream_interfaces/c7_ledger/ledger/specs/openapi_3.4.7.yaml
+// Generated from /Users/stefanpla/Development/c7/c7_ledger/c7_ledger/ledger/specs/openapi_3.4.7.yaml
 export const OPENAPI_SCHEMA = `openapi: 3.0.3
 info:
   title: JSON Ledger API HTTP endpoints

package/lib/src/validation.d.ts

@@ -15,6 +15,11 @@ export declare class SchemaValidator {
      * Helper function to handle errors based on the validation mode
      */
     private handleError;
+    /**
+     * Transform schema to allow null values for non-required fields
+     * This handles the common OpenAPI pattern where optional fields can be null
+     */
+    private makeOptionalFieldsNullable;
     private loadSchemasFromContent;
     /**
      * Validate an array of items against a schema

package/lib/src/validation.js

@@ -95,6 +95,61 @@ export class SchemaValidator {
             throw error instanceof Error ? error : new Error(message);
         }
     }
+    /**
+     * Transform schema to allow null values for non-required fields
+     * This handles the common OpenAPI pattern where optional fields can be null
+     */
+    makeOptionalFieldsNullable(schema) {
+        if (!schema || typeof schema !== "object")
+            return schema;
+        // Handle arrays - recursively transform each element
+        if (Array.isArray(schema)) {
+            return schema.map((item) => this.makeOptionalFieldsNullable(item));
+        }
+        const transformed = { ...schema };
+        // If this is an object schema with properties
+        if (transformed.type === "object" && transformed.properties) {
+            const required = new Set(transformed.required || []);
+            // For each property that's not required, allow null values
+            for (const [propName, propSchema] of Object.entries(transformed.properties)) {
+                if (!required.has(propName) && typeof propSchema === "object" && !Array.isArray(propSchema)) {
+                    // If it has a simple type and isn't already allowing null
+                    if (propSchema.type && typeof propSchema.type === "string" && propSchema.type !== "null") {
+                        // Make it accept both the original type and null
+                        transformed.properties[propName] = {
+                            ...propSchema,
+                            anyOf: [
+                                { ...propSchema, type: propSchema.type },
+                                { type: "null" }
+                            ]
+                        };
+                        // Remove the type field as it's now in anyOf
+                        delete transformed.properties[propName].type;
+                    }
+                }
+                // Recursively transform nested schemas
+                const nestedSchema = transformed.properties[propName];
+                if (nestedSchema) {
+                    transformed.properties[propName] = this.makeOptionalFieldsNullable(nestedSchema);
+                }
+            }
+        }
+        // Handle $ref - don't transform, let AJV resolve it
+        if (transformed.$ref) {
+            return transformed;
+        }
+        // Recursively handle nested schemas in allOf, anyOf, oneOf
+        if (transformed.allOf) {
+            transformed.allOf = transformed.allOf.map((s) => this.makeOptionalFieldsNullable(s));
+        }
+        if (transformed.anyOf) {
+            transformed.anyOf = transformed.anyOf.map((s) => this.makeOptionalFieldsNullable(s));
+        }
+        if (transformed.oneOf) {
+            transformed.oneOf = transformed.oneOf.map((s) => this.makeOptionalFieldsNullable(s));
+        }
+        return transformed;
+    }
     async loadSchemasFromContent(yamlContent) {
         if (!this.ajv)
             return;
@@ -104,6 +159,23 @@ export class SchemaValidator {
             const spec = yaml.parse(yamlContent);
             // Load the complete schema document first to enable reference resolution
             if (spec?.components?.schemas) {
+                // Transform schemas to allow null for optional fields
+                for (const [schemaName, schemaDefinition] of Object.entries(spec.components.schemas)) {
+                    const transformed = this.makeOptionalFieldsNullable(schemaDefinition);
+                    // Schemas in the components should always be objects, not arrays
+                    if (transformed) {
+                        if (Array.isArray(transformed)) {
+                            // Arrays shouldn't appear at the schema root level, but handle gracefully
+                            const firstItem = transformed[0];
+                            if (firstItem) {
+                                spec.components.schemas[schemaName] = firstItem;
+                            }
+                        }
+                        else {
+                            spec.components.schemas[schemaName] = transformed;
+                        }
+                    }
+                }
                 // Add the full schema document with an ID so references can be resolved
                 this.ajv.addSchema(spec, "#");
                 logger.debug(`Added full schema document with ID "#"`);
@@ -168,7 +240,10 @@ export class SchemaValidator {
             }
             const isValid = this.ajv.validate(schemaName, data);
             if (!isValid) {
-                this.handleError(`Schema validation failed for ${schemaName}:`, new Error(`Schema validation failed for ${schemaName}: ${this.ajv.errorsText()}`));
+                const errorDetails = this.ajv.errorsText();
+                logger.warn(`Validation errors: ${errorDetails}`);
+                logger.debug(`Full validation errors:`, this.ajv.errors);
+                this.handleError(`Schema validation failed for ${schemaName}: ${errorDetails}`, new Error(`Schema validation failed for ${schemaName}: ${errorDetails}`));
             }
             else {
                 logger.debug(`Validation successful for "${schemaName}"`);