@onlineapps/service-validator-core 1.0.11 → 1.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/service-validator-core",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "Core validation logic for microservices",
   "main": "src/index.js",
   "scripts": {

package/src/config.js

@@ -28,3 +28,6 @@ const runtimeCfg = createRuntimeConfig({
 module.exports = runtimeCfg;
 
 
+
+
+

package/src/defaults.js

@@ -15,3 +15,6 @@ module.exports = {
 };
 
 
+
+
+

package/src/utils/FingerprintUtils.js

@@ -52,12 +52,20 @@ class FingerprintUtils {
   }
 
   /**
-   * Generate fingerprint for service configuration
-   * Used for cache validation - skip re-validation if config unchanged
+   * Generate fingerprint for service configuration.
+   * Used for cache validation - skip re-validation if config unchanged.
+   *
+   * The fingerprint input includes `operations` (per the Operations Registry
+   * contract) so that changes to `mutates` / `resource_type` / schemas
+   * invalidate the cached validation proof as expected.
+   *
+   * @see api/docs/standards/operations-registry-contract.md §6 Fingerprint
+   * @see api/docs/standards/OPERATIONS.md
    *
    * @param {Object} config - Service configuration
    * @param {string} config.version - Service version (REQUIRED)
-   * @param {Array} config.endpoints - API endpoints (REQUIRED)
+   * @param {Array}  config.endpoints - API endpoints (REQUIRED, may be empty)
+   * @param {Object} config.operations - Operations map from operations.json (REQUIRED, may be empty)
    * @param {Object} config.metadata - Service metadata (REQUIRED)
    * @param {string} config.health - Health check endpoint (REQUIRED)
    * @returns {string} Configuration fingerprint
@@ -73,6 +81,9 @@ class FingerprintUtils {
     if (!Array.isArray(config.endpoints)) {
       throw new Error('config.endpoints must be an array');
     }
+    if (typeof config.operations !== 'object' || config.operations === null || Array.isArray(config.operations)) {
+      throw new Error('config.operations must be an object (see operations-registry-contract.md §3)');
+    }
     if (typeof config.metadata !== 'object' || config.metadata === null) {
       throw new Error('config.metadata must be an object');
     }
@@ -80,12 +91,17 @@ class FingerprintUtils {
       throw new Error('config.health is required');
     }
 
-    return this.generate({
+    // Stable, deep-sorted JSON so nested operation schemas actually contribute
+    // to the hash. The generic generate() uses JSON.stringify(data, keys) which
+    // filters keys recursively and would drop nested operation properties.
+    const stable = _stableStringify({
       version: config.version,
       endpoints: config.endpoints,
+      operations: config.operations,
       metadata: config.metadata,
       health: config.health
     });
+    return crypto.createHash('sha256').update(stable).digest('hex');
   }
 
   /**
@@ -123,4 +139,24 @@ class FingerprintUtils {
   }
 }
 
+/**
+ * Deep stable JSON serializer — sorts keys at every depth so that
+ * logically-equal objects always produce the same string (and therefore the
+ * same hash), regardless of key insertion order.
+ *
+ * Private helper: only used by generateConfigFingerprint to avoid the
+ * recursive-filter bug in JSON.stringify(data, keysArray).
+ */
+function _stableStringify(value) {
+  if (value === null || typeof value !== 'object') {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return '[' + value.map(_stableStringify).join(',') + ']';
+  }
+  const keys = Object.keys(value).sort();
+  const parts = keys.map(k => JSON.stringify(k) + ':' + _stableStringify(value[k]));
+  return '{' + parts.join(',') + '}';
+}
+
 module.exports = FingerprintUtils;

package/tests/unit/FingerprintUtils.test.js

@@ -0,0 +1,80 @@
+const FingerprintUtils = require('../../src/utils/FingerprintUtils');
+
+/**
+ * Unit tests for FingerprintUtils.generateConfigFingerprint — verifies that
+ * `operations` is a required input so changes to mutates / resource_type
+ * invalidate the cached validation proof.
+ *
+ * @see api/docs/standards/operations-registry-contract.md §6 Fingerprint
+ */
+describe('FingerprintUtils.generateConfigFingerprint @unit', () => {
+  const baseConfig = () => ({
+    version: '1.0.0',
+    endpoints: [],
+    operations: {},
+    metadata: {},
+    health: '/health'
+  });
+
+  it('returns a 64-char SHA256 hex for a valid config', () => {
+    const hash = FingerprintUtils.generateConfigFingerprint(baseConfig());
+    expect(typeof hash).toBe('string');
+    expect(hash).toMatch(/^[0-9a-f]{64}$/);
+  });
+
+  it('produces a different fingerprint when operations change', () => {
+    const a = FingerprintUtils.generateConfigFingerprint({
+      ...baseConfig(),
+      operations: { 'get-x': { mutates: false, resource_type: null } }
+    });
+    const b = FingerprintUtils.generateConfigFingerprint({
+      ...baseConfig(),
+      operations: { 'get-x': { mutates: true, resource_type: 'doc' } }
+    });
+    expect(a).not.toEqual(b);
+  });
+
+  it('throws when operations is missing', () => {
+    const cfg = baseConfig();
+    delete cfg.operations;
+    expect(() => FingerprintUtils.generateConfigFingerprint(cfg))
+      .toThrow(/operations must be an object/);
+  });
+
+  it('throws when operations is an array (must be a keyed object)', () => {
+    expect(() => FingerprintUtils.generateConfigFingerprint({
+      ...baseConfig(),
+      operations: []
+    })).toThrow(/operations must be an object/);
+  });
+
+  it('throws when operations is null', () => {
+    expect(() => FingerprintUtils.generateConfigFingerprint({
+      ...baseConfig(),
+      operations: null
+    })).toThrow(/operations must be an object/);
+  });
+
+  it('accepts an empty operations object (service with no operations yet)', () => {
+    const hash = FingerprintUtils.generateConfigFingerprint({
+      ...baseConfig(),
+      operations: {}
+    });
+    expect(hash).toMatch(/^[0-9a-f]{64}$/);
+  });
+
+  it('still enforces other required fields', () => {
+    expect(() => FingerprintUtils.generateConfigFingerprint({
+      endpoints: [], operations: {}, metadata: {}, health: '/h'
+    })).toThrow(/version is required/);
+    expect(() => FingerprintUtils.generateConfigFingerprint({
+      version: '1', operations: {}, metadata: {}, health: '/h'
+    })).toThrow(/endpoints must be an array/);
+    expect(() => FingerprintUtils.generateConfigFingerprint({
+      version: '1', endpoints: [], operations: {}, health: '/h'
+    })).toThrow(/metadata must be an object/);
+    expect(() => FingerprintUtils.generateConfigFingerprint({
+      version: '1', endpoints: [], operations: {}, metadata: {}
+    })).toThrow(/health is required/);
+  });
+});