@epilot/entity-client 4.21.0 → 4.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epilot/entity-client",
-  "version": "4.21.0",
+  "version": "4.23.0",
   "description": "JavaScript client library for the epilot Core Entity API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/client.test.ts

@@ -0,0 +1,25 @@
+import { getClient } from './client';
+
+describe('client', () => {
+  describe('getClient', () => {
+    it('should inititalise and return client', async () => {
+      const client = getClient();
+
+      expect(client.api.initialized).toBe(true);
+    });
+
+    it('should have operations', async () => {
+      const client = getClient();
+
+      const operations = client.api.getOperations();
+
+      expect(operations.length).toBeGreaterThan(0);
+    });
+
+    it('should have a default server defined', async () => {
+      const client = getClient();
+
+      expect(client.defaults.baseURL).toBeDefined();
+    });
+  });
+});

package/src/client.ts

@@ -0,0 +1,26 @@
+import CorrelationIds from '@dazn/lambda-powertools-correlation-ids';
+import OpenAPIClientAxios from 'openapi-client-axios';
+
+import definition from './definition';
+import { Client } from './openapi';
+
+let client: Client;
+export const getClient = () => {
+  if (!client) {
+    client = createClient();
+  }
+
+  return client;
+};
+
+export const createClient = () => {
+  const api = new OpenAPIClientAxios({ definition, quick: true });
+  const apiClient = api.initSync<Client>();
+
+  apiClient.defaults.headers.common = {
+    ...(apiClient.defaults.headers.common ?? {}),
+    ...(CorrelationIds.get() || {}),
+  };
+
+  return apiClient;
+};

package/src/definition.ts

@@ -0,0 +1,5 @@
+import type { Document } from 'openapi-client-axios';
+
+import definition from './openapi-runtime.json';
+
+export default (definition as unknown) as Document;

package/{dist → src}/openapi-runtime.json

@@ -646,6 +646,26 @@
             "in": "query",
             "name": "slug",
             "required": false
+          },
+          {
+            "in": "query",
+            "name": "sort",
+            "required": false
+          },
+          {
+            "in": "query",
+            "name": "from",
+            "required": false
+          },
+          {
+            "in": "query",
+            "name": "size",
+            "required": false
+          },
+          {
+            "in": "query",
+            "name": "fields",
+            "required": false
           }
         ]
       }
@@ -785,7 +805,11 @@
         "operationId": "taxonomiesClassificationsSearch",
         "parameters": [
           {
-            "$ref": "#/components/parameters/TaxonomySlugQueryParam"
+            "$ref": "#/components/parameters/TaxonomySlugQueryParamOptional"
+          },
+          {
+            "in": "query",
+            "name": "query"
           }
         ],
         "requestBody": {
@@ -810,18 +834,7 @@
         }
       }
     },
-    "/v2/entity/taxonomies/{taxonomySlug}/classifications/{classificationSlug}": {
-      "get": {
-        "operationId": "getTaxonomyClassification",
-        "parameters": [
-          {
-            "$ref": "#/components/parameters/TaxonomySlugPathParam"
-          },
-          {
-            "$ref": "#/components/parameters/TaxonomyClassificationSlugPathParam"
-          }
-        ]
-      },
+    "/v2/entity/taxonomies/{taxonomySlug}/classifications": {
       "post": {
         "operationId": "createTaxonomyClassification",
         "parameters": [
@@ -833,41 +846,24 @@
           "content": {
             "application/json": {}
           }
-        },
-        "response": {
-          "201": {
-            "description": "Taxonomy classification created",
-            "content": {
-              "application/json": {}
-            }
-          },
-          "409": {
-            "description": "Taxonomy classification already exists\""
-          }
         }
-      },
+      }
+    },
+    "/v2/entity/taxonomies/{taxonomySlug}/classifications/{classificationSlug}": {
       "put": {
         "operationId": "updateTaxonomyClassification",
         "parameters": [
           {
             "$ref": "#/components/parameters/TaxonomySlugPathParam"
+          },
+          {
+            "$ref": "#/components/parameters/TaxonomyClassificationSlugPathParam"
           }
         ],
         "requestBody": {
           "content": {
             "application/json": {}
           }
-        },
-        "response": {
-          "200": {
-            "description": "Taxonomy classification updated",
-            "content": {
-              "application/json": {}
-            }
-          },
-          "404": {
-            "description": "Taxonomy classification not found"
-          }
         }
       },
       "delete": {
@@ -877,20 +873,87 @@
             "$ref": "#/components/parameters/TaxonomySlugPathParam"
           },
           {
-            "in": "path",
-            "name": "classificationId",
-            "required": true
+            "$ref": "#/components/parameters/TaxonomyClassificationSlugPathParam"
           },
           {
             "in": "query",
             "name": "permanent"
           }
+        ]
+      }
+    },
+    "/v1/entity/schemas/attributes/{composite_id}": {
+      "get": {
+        "operationId": "getSchemaAttribute",
+        "parameters": [
+          {
+            "name": "composite_id",
+            "in": "path",
+            "required": true
+          }
+        ]
+      },
+      "put": {
+        "operationId": "putSchemaAttribute",
+        "parameters": [
+          {
+            "name": "composite_id",
+            "in": "path",
+            "required": true
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {}
+          }
+        }
+      },
+      "delete": {
+        "operationId": "deleteSchemaAttribute",
+        "parameters": [
+          {
+            "name": "composite_id",
+            "in": "path",
+            "required": true
+          }
+        ]
+      }
+    },
+    "/v1/entity/schemas/capabilities/{composite_id}": {
+      "get": {
+        "operationId": "getSchemaCapability",
+        "parameters": [
+          {
+            "name": "composite_id",
+            "in": "path",
+            "required": true
+          }
+        ]
+      },
+      "put": {
+        "operationId": "putSchemaCapability",
+        "parameters": [
+          {
+            "name": "composite_id",
+            "in": "path",
+            "required": true
+          }
         ],
-        "response": {
-          "204": {
-            "description": "Taxonomy classification deleted"
+        "requestBody": {
+          "content": {
+            "application/json": {}
           }
         }
+      },
+      "delete": {
+        "operationId": "deleteSchemaCapability",
+        "parameters": [
+          {
+            "name": "composite_id",
+            "in": "path",
+            "required": true
+          }
+        ]
       }
     }
   },
@@ -911,18 +974,17 @@
         "in": "path",
         "required": true
       },
-      "TaxonomySlugQueryParam": {
-        "name": "taxonomySlug",
-        "in": "query",
-        "required": true
-      },
       "TaxonomySlugPathParam": {
         "name": "taxonomySlug",
         "in": "path",
         "required": true
       },
+      "TaxonomySlugQueryParamOptional": {
+        "name": "taxonomySlug",
+        "in": "query"
+      },
       "TaxonomyClassificationSlugPathParam": {
-        "name": "taxonomyClassificationSlug",
+        "name": "classificationSlug",
         "in": "path",
         "required": true
       },