chore: updating definition of customDomainProperty

Signed-off-by: Pawel Psztyc <[email protected]>

Author: jarrodek

package-lock.json

@@ -1,7 +1,7 @@
 {
   "name": "@api-components/amf-helper-mixin",
   "description": "A mixin with common functions user by most AMF components to compute AMF values",
-  "version": "4.5.8",
+  "version": "4.5.9",
   "license": "Apache-2.0",
   "main": "index.js",
   "module": "index.js",

package.json

@@ -992,11 +992,16 @@ export class AmfSerializer extends AmfHelperMixin(Object) {
         if (Array.isArray(value)) {
           [value] = value;
         }
-        const cdp = /** @type ApiCustomDomainProperty */ (this.unknownDataNode(value));
-        const extensionName = this._getValue(value, this.ns.aml.vocabularies.core.extensionName);
-        if (extensionName && typeof extensionName === 'string') {
-          cdp.extensionName = extensionName;
+        const extension = this.unknownDataNode(value);
+        const name = this._getValue(value, this.ns.aml.vocabularies.core.extensionName);
+        if (!name || !extension) {
+          return;
         }
+        const cdp = /** @type ApiCustomDomainProperty */ ({
+          id: key,
+          name,
+          extension,
+        });
         result.push(cdp);
       });
     }
@@ -1762,8 +1767,8 @@ export class AmfSerializer extends AmfHelperMixin(Object) {
       [sm] = sm;
     }
     const result = /** @type ApiDocumentSourceMaps */ ({
-      id: object['@id'],
-      types: object['@type'].map(this[expandKey].bind(this)),
+      id: sm['@id'],
+      types: sm['@type'].map(this[expandKey].bind(this)),
     });
     const sf = sm[this._getAmfKey(ns.aml.vocabularies.docSourceMaps.synthesizedField)];
     if (Array.isArray(sf) && sf.length) {

src/AmfSerializer.js

@@ -58,8 +58,10 @@ export interface ApiDomainProperty {
   customDomainProperties: ApiCustomDomainProperty[];
 }
 
-export interface ApiCustomDomainProperty extends ApiDataNode {
-  extensionName: string;
+export interface ApiCustomDomainProperty {
+  id: string;
+  name: string;
+  extension: ApiDataNodeUnion;
 }
 
 export type ScalarDataTypes = 'string' | 'base64Binary' | 'boolean' | 'date' | 'dateTime' | 'double' | 'float' | 'integer' | 'long' | 'number' | 'time';

src/types.d.ts

@@ -7,7 +7,7 @@ import { AmfSerializer } from "../../index.js";
 
 describe("AmfSerializer", () => {
   describe("Annotations", () => {
-    [true, ].forEach((compact) => {
+    [true, false].forEach((compact) => {
       describe(compact ? "Compact model" : "Full model", () => {
         let api;
         /** @type AmfSerializer */
@@ -26,8 +26,9 @@ describe("AmfSerializer", () => {
           assert.typeOf(customDomainProperties, 'array', 'has the customDomainProperties');
           assert.lengthOf(customDomainProperties, 1, 'has a single annotation');
           const [annotation] = customDomainProperties;
-          assert.equal(annotation.extensionName, 'clearanceLevel', 'has the extensionName');
-          const { properties } = /** @type ApiObjectNode */ (/** @type unknown */ (annotation));
+          assert.equal(annotation.name, 'clearanceLevel', 'has the extensionName');
+          assert.typeOf(annotation.extension, 'object', 'has the extension');
+          const { properties } = /** @type ApiObjectNode */ (annotation.extension);
           assert.typeOf(properties, 'object', 'has properties');
           const { level, signature } = properties;
           assert.typeOf(level, 'object', 'has the level property');
@@ -42,8 +43,10 @@ describe("AmfSerializer", () => {
           assert.typeOf(customDomainProperties, 'array', 'has the customDomainProperties');
           assert.lengthOf(customDomainProperties, 1, 'has a single annotation');
           const [annotation] = customDomainProperties;
-          assert.equal(annotation.extensionName, 'deprecated', 'has the extensionName');
-          const { value, dataType, } = /** @type ApiScalarNode */ (/** @type unknown */ (annotation));
+          assert.equal(annotation.name, 'deprecated', 'has the extensionName');
+          assert.typeOf(annotation.extension, 'object', 'has the extension');
+
+          const { value, dataType, } = /** @type ApiScalarNode */ (annotation.extension);
           assert.equal(dataType, 'http://www.w3.org/2001/XMLSchema#string', 'has the dataType');
           assert.equal(value, 'This operation is deprecated and will be removed.', 'has the value');
         });

test/serializer/Anotations.test.js

@@ -59,10 +59,8 @@ describe('AmfSerializer', () => {
       assert.typeOf(result.customDomainProperties, 'array', 'has the array');
       assert.lengthOf(result.customDomainProperties, 1, 'has the annotation');
       const [item] = result.customDomainProperties;
-      assert.include(item.types, serializer.ns.aml.vocabularies.data.Object, 'has the Object type');
-      assert.equal(item.name, 'object_1', 'has the name');
-      assert.equal(item.extensionName, 'clearanceLevel', 'has the extensionName');
-      const typed = /** @type ApiObjectNode */ (/** @type unknown */(item));
+      assert.equal(item.name, 'clearanceLevel', 'has the name');
+      const typed = /** @type ApiObjectNode */ (item.extension);
       assert.typeOf(typed.properties, 'object', 'has the properties');
       assert.lengthOf(Object.keys(typed.properties), 2, 'has all properties');
     });

test/serializer/Endpoints.test.js

@@ -238,10 +238,9 @@ describe('AmfSerializer', () => {
         assert.typeOf(customDomainProperties, 'array', 'has the security');
         assert.lengthOf(customDomainProperties, 1, 'has the defined security');
         const [cdp] = customDomainProperties;
-        assert.include(cdp.types, serializer.ns.aml.vocabularies.data.Scalar, 'has the type');
-        assert.equal(cdp.name, 'scalar_1', 'has the name');
-        assert.equal(cdp.extensionName, 'deprecated', 'has the extensionName');
-        const typed = /** @type ApiScalarNode */ (cdp);
+        assert.equal(cdp.name, 'deprecated', 'has the name');
+        const typed = /** @type ApiScalarNode */ (cdp.extension);
+        assert.include(typed.types, serializer.ns.aml.vocabularies.data.Scalar, 'has the type');
         assert.equal(typed.value, 'This operation is deprecated and will be removed.', 'has the value');
         assert.equal(typed.dataType, serializer.ns.w3.xmlSchema.string, 'has the dataType');
       });
@@ -273,8 +272,8 @@ describe('AmfSerializer', () => {
         assert.typeOf(customDomainProperties, 'array', 'has the customDomainProperties');
         const [cdp] = customDomainProperties;
         assert.typeOf(cdp, 'object', 'has the property');
-        assert.include(cdp.types, serializer.ns.aml.vocabularies.data.Scalar, 'has the type');
-        assert.equal(cdp.extensionName, 'deprecated', 'has the extensionName');
+        assert.include(cdp.extension.types, serializer.ns.aml.vocabularies.data.Scalar, 'has the type');
+        assert.equal(cdp.name, 'deprecated', 'has the extensionName');
       });
 
       it('adds query parameters from a trait', () => {

test/serializer/Operations.test.js

@@ -171,12 +171,10 @@ describe('AmfSerializer', () => {
       assert.lengthOf(cdp, 1, 'has a single property');
       const [item] = cdp;
       assert.typeOf(item.id, 'string', 'has the id');
-      assert.include(item.types, serializer.ns.aml.vocabularies.data.Scalar, 'has the Scalar type');
-      assert.equal(item.name, 'scalar_1', 'has the name');
-      assert.equal(item.extensionName, 'deprecated', 'has the extensionName');
+      assert.include(item.extension.types, serializer.ns.aml.vocabularies.data.Scalar, 'has the Scalar type');
+      assert.equal(item.name, 'deprecated', 'has the extensionName');
       // @ts-ignore
-      assert.typeOf(item.value, 'string', 'has the value');
-      assert.deepEqual(item.customDomainProperties, [], 'has empty customDomainProperties');
+      assert.typeOf(item.extension.value, 'string', 'has the value');
     });
 
     it('processes a SchemaShape', () => {
@@ -279,11 +277,10 @@ describe('AmfSerializer', () => {
       const result = /** @type ApiNodeShape */ (serializer.unknownShape(shape));
       assert.lengthOf(result.customDomainProperties, 1, 'has the customDomainProperties');
       const [cdp] = result.customDomainProperties;
-      assert.include(cdp.types, serializer.ns.aml.vocabularies.data.Scalar, 'has the Scalar type');
-      assert.deepEqual(cdp.customDomainProperties, [], 'has empty customDomainProperties');
-      assert.equal(cdp.name, 'scalar_1', 'has the name');
-      assert.equal(cdp.extensionName, 'swagger-router-model', 'has the extensionName');
-      const typed = /** @type ApiScalarNode */ (cdp);
+      assert.equal(cdp.name, 'swagger-router-model', 'has the name');
+      const typed = /** @type ApiScalarNode */ (cdp.extension);
+      assert.include(typed.types, serializer.ns.aml.vocabularies.data.Scalar, 'has the Scalar type');
+      assert.deepEqual(typed.customDomainProperties, [], 'has empty customDomainProperties');
       assert.equal(typed.dataType, serializer.ns.w3.xmlSchema.string, 'has the dataType');
       assert.equal(typed.value, 'io.swagger.petstore.model.Pet', 'has the value');
     });