swoop-common 2.1.50 → 2.1.52

package/dist/api/additions/templateHierarchyResolver.js

@@ -43,59 +43,62 @@ const buildTemplateTree = (templates) => {
 };
 export const resolveTemplateHierarchy = (templateId) => __awaiter(void 0, void 0, void 0, function* () {
     // First fetch all templates
-    const allTemplates = yield (new CoreService).templateList(1);
-    // Find the initial template
-    const initialTemplate = allTemplates.data.find((t) => t.id === templateId);
-    if (!initialTemplate) {
-        throw new Error(`Template with ID ${templateId} not found`);
-    }
-    // Build the complete template tree
-    const templateTree = buildTemplateTree(allTemplates.data);
-    // Find the group containing our template
-    const findGroup = (groups) => {
-        for (const group of groups) {
-            if (group.versions.some((t) => t.id === templateId)) {
-                return group;
+    const allTemplates = yield new CoreService().templateList(1);
+    if (allTemplates.data) {
+        // Find the initial template
+        const initialTemplate = allTemplates.data.find((t) => t.id === templateId);
+        if (!initialTemplate) {
+            throw new Error(`Template with ID ${templateId} not found`);
+        }
+        // Build the complete template tree
+        const templateTree = buildTemplateTree(allTemplates.data);
+        // Find the group containing our template
+        const findGroup = (groups) => {
+            for (const group of groups) {
+                if (group.versions.some((t) => t.id === templateId)) {
+                    return group;
+                }
+                const found = findGroup(group.children);
+                if (found)
+                    return found;
             }
-            const found = findGroup(group.children);
-            if (found)
-                return found;
+            return undefined;
+        };
+        const targetGroup = findGroup(templateTree);
+        if (!targetGroup) {
+            throw new Error(`Could not find template group for template ${templateId}`);
         }
-        return undefined;
-    };
-    const targetGroup = findGroup(templateTree);
-    if (!targetGroup) {
-        throw new Error(`Could not find template group for template ${templateId}`);
-    }
-    // Build the hierarchy by following parent links
-    const hierarchy = [];
-    let currentGroup = targetGroup;
-    while (currentGroup) {
-        // Get the latest version of the current group
-        const latestTemplate = currentGroup.versions.reduce((a, b) => a.revision > b.revision ? a : b);
-        hierarchy.unshift(latestTemplate); // Add to beginning to get root -> leaf order
-        // Move up to parent group
-        if (currentGroup.parentRevisionGroupId) {
-            // Find the parent group in the tree
-            const findParentGroup = (groups) => {
-                for (const group of groups) {
-                    if (group.revisionGroupId === currentGroup.parentRevisionGroupId) {
-                        return group;
+        // Build the hierarchy by following parent links
+        const hierarchy = [];
+        let currentGroup = targetGroup;
+        while (currentGroup) {
+            // Get the latest version of the current group
+            const latestTemplate = currentGroup.versions.reduce((a, b) => a.revision > b.revision ? a : b);
+            hierarchy.unshift(latestTemplate); // Add to beginning to get root -> leaf order
+            // Move up to parent group
+            if (currentGroup.parentRevisionGroupId) {
+                // Find the parent group in the tree
+                const findParentGroup = (groups) => {
+                    for (const group of groups) {
+                        if (group.revisionGroupId === currentGroup.parentRevisionGroupId) {
+                            return group;
+                        }
+                        const found = findParentGroup(group.children);
+                        if (found)
+                            return found;
                     }
-                    const found = findParentGroup(group.children);
-                    if (found)
-                        return found;
-                }
-                return undefined;
-            };
-            const parentGroup = findParentGroup(templateTree);
-            if (!parentGroup)
+                    return undefined;
+                };
+                const parentGroup = findParentGroup(templateTree);
+                if (!parentGroup)
+                    break;
+                currentGroup = parentGroup;
+            }
+            else {
                 break;
-            currentGroup = parentGroup;
-        }
-        else {
-            break;
+            }
         }
+        return hierarchy; // Already in root -> leaf order
     }
-    return hierarchy; // Already in root -> leaf order
+    return [];
 });

package/dist/api/generated/core/core/OpenAPI.js

@@ -1,6 +1,6 @@
 export const OpenAPI = {
-    BASE: 'placeholder',
-    VERSION: '1.0.0',
+    BASE: 'https://data-api-dev.swoop-adventures.com/core-data-service/v1',
+    VERSION: '1',
     WITH_CREDENTIALS: false,
     CREDENTIALS: 'include',
     TOKEN: undefined,

package/dist/api/generated/core/index.d.ts

@@ -67,4 +67,6 @@ export type { sortParam } from './models/sortParam';
 export type { templateId } from './models/templateId';
 export type { UserComponentInstanceField } from './models/UserComponentInstanceField';
 export type { ValidationSchemas } from './models/ValidationSchemas';
+export { ComponentService } from './services/ComponentService';
 export { CoreService } from './services/CoreService';
+export { TemplateService } from './services/TemplateService';

package/dist/api/generated/core/index.js

@@ -11,4 +11,6 @@ export { Currency } from './models/Currency';
 export { Meals } from './models/Meals';
 export { regionParam } from './models/regionParam';
 export { regionRequired } from './models/regionRequired';
+export { ComponentService } from './services/ComponentService';
 export { CoreService } from './services/CoreService';
+export { TemplateService } from './services/TemplateService';

package/dist/api/generated/core/models/DTOSnapshotCreate.d.ts

@@ -1,4 +1,5 @@
 export type DTOSnapshotCreate = {
     name: string;
     itineraryId: string;
+    enquiryId: string;
 };

package/dist/api/generated/core/models/DTOSnapshotEntity.d.ts

@@ -4,4 +4,5 @@ export type DTOSnapshotEntity = {
     metadata: Metadata;
     name: string;
     itineraryId: string;
+    enquiryId: string;
 };

package/dist/api/generated/core/models/DTOSnapshotRead.d.ts

@@ -4,4 +4,5 @@ export type DTOSnapshotRead = {
     metadata: Metadata;
     name: string;
     itineraryId: string;
+    enquiryId: string;
 };

package/dist/api/generated/core/services/ComponentService.d.ts

@@ -0,0 +1,73 @@
+import type { DTOComponentCreate } from '../models/DTOComponentCreate';
+import type { DTOComponentRead } from '../models/DTOComponentRead';
+import type { DTOComponentUpdate } from '../models/DTOComponentUpdate';
+import type { Pagination } from '../models/Pagination';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class ComponentService {
+    /**
+     * List Component
+     * List all available component
+     * @param page Pagination, starting at page 1
+     * @param limit Number of items per page
+     * @param sort List of fields to sort by
+     * @returns any The list of all component given the parameters used
+     * @throws ApiError
+     */
+    static componentList(page?: number, limit?: number, sort?: any[]): CancelablePromise<{
+        data?: Array<DTOComponentRead>;
+        pagination?: Pagination;
+    }>;
+    /**
+     * Create a Component
+     * Creates a new Component
+     * @param requestBody
+     * @returns DTOComponentRead When a component is created
+     * @throws ApiError
+     */
+    static componentCreate(requestBody: DTOComponentCreate): CancelablePromise<DTOComponentRead>;
+    /**
+     * Get Component
+     * Get Component via ID
+     * @param componentId Id of a component
+     * @returns any OK
+     * @throws ApiError
+     */
+    static componentGet(componentId: string): CancelablePromise<any>;
+    /**
+     * Update Component as New Revision
+     * Updates an component as a new revision
+     * @param componentId Id of a component
+     * @param requestBody
+     * @returns DTOComponentRead When a new component is created successfully
+     * @throws ApiError
+     */
+    static componentUpdateAsNewRevision(componentId: string, requestBody: DTOComponentUpdate): CancelablePromise<DTOComponentRead>;
+    /**
+     * Update Component
+     * Updates an component
+     * @param componentId Id of a component
+     * @param requestBody
+     * @returns DTOComponentRead When a component is updated successfully
+     * @throws ApiError
+     */
+    static componentUpdate(componentId: string, requestBody: DTOComponentUpdate): CancelablePromise<DTOComponentRead>;
+    /**
+     * Delete Component via ID
+     * Deletes a specific component given its Id
+     * @param componentId Id of a component
+     * @returns void
+     * @throws ApiError
+     */
+    static componentDelete(componentId: string): CancelablePromise<void>;
+    /**
+     * Update Component State
+     * Directly update component state. This does not create a new revision
+     * @param componentId Id of a component
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    static componentStateUpdate(componentId: string, requestBody: {
+        state?: 'published' | 'deprecated' | 'unpublished';
+    }): CancelablePromise<any>;
+}

package/dist/api/generated/core/services/ComponentService.js

@@ -0,0 +1,171 @@
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ComponentService {
+    /**
+     * List Component
+     * List all available component
+     * @param page Pagination, starting at page 1
+     * @param limit Number of items per page
+     * @param sort List of fields to sort by
+     * @returns any The list of all component given the parameters used
+     * @throws ApiError
+     */
+    static componentList(page, limit, sort) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/components',
+            query: {
+                'page': page,
+                'limit': limit,
+                'sort': sort,
+            },
+            errors: {
+                400: `If the filter options or query parameters contain invalid values`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                500: `When an internal server error occurs when listing all related component`,
+            },
+        });
+    }
+    /**
+     * Create a Component
+     * Creates a new Component
+     * @param requestBody
+     * @returns DTOComponentRead When a component is created
+     * @throws ApiError
+     */
+    static componentCreate(requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/components',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `If the payload is malformed`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                500: `Internal Server Error`,
+            },
+        });
+    }
+    /**
+     * Get Component
+     * Get Component via ID
+     * @param componentId Id of a component
+     * @returns any OK
+     * @throws ApiError
+     */
+    static componentGet(componentId) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/components/{componentId}',
+            path: {
+                'componentId': componentId,
+            },
+            errors: {
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                404: `If the component does not exist`,
+            },
+        });
+    }
+    /**
+     * Update Component as New Revision
+     * Updates an component as a new revision
+     * @param componentId Id of a component
+     * @param requestBody
+     * @returns DTOComponentRead When a new component is created successfully
+     * @throws ApiError
+     */
+    static componentUpdateAsNewRevision(componentId, requestBody) {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/components/{componentId}',
+            path: {
+                'componentId': componentId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `If the payload is malformed`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                404: `When the component id to create a new revision from is not found`,
+                500: `When an internal server error occurs updating a component as a new revision`,
+            },
+        });
+    }
+    /**
+     * Update Component
+     * Updates an component
+     * @param componentId Id of a component
+     * @param requestBody
+     * @returns DTOComponentRead When a component is updated successfully
+     * @throws ApiError
+     */
+    static componentUpdate(componentId, requestBody) {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/components/{componentId}',
+            path: {
+                'componentId': componentId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `If the payload is malformed`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                404: `When the component id to update is not found`,
+                500: `When an internal server error occurs updating a component`,
+            },
+        });
+    }
+    /**
+     * Delete Component via ID
+     * Deletes a specific component given its Id
+     * @param componentId Id of a component
+     * @returns void
+     * @throws ApiError
+     */
+    static componentDelete(componentId) {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/components/{componentId}',
+            path: {
+                'componentId': componentId,
+            },
+            errors: {
+                400: `When the component doesn't exist in the first place, or when a before hook fails before deleting the item`,
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                404: `Not Found`,
+                500: `When the component fails to delete due to an internal server error`,
+            },
+        });
+    }
+    /**
+     * Update Component State
+     * Directly update component state. This does not create a new revision
+     * @param componentId Id of a component
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    static componentStateUpdate(componentId, requestBody) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/components/{componentId}/state',
+            path: {
+                'componentId': componentId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized - Missing or invalid Authorization header`,
+                403: `Forbidden - The client is authenticated but not authorized to access this resource`,
+                404: `Not Found`,
+            },
+        });
+    }
+}

package/dist/api/generated/core/services/CoreService.d.ts

@@ -9,93 +9,105 @@ import { CancelablePromise } from '../core/CancelablePromise';
 export declare class CoreService {
     /**
      * List Templates
-     * List all templates with pagination
+     * List all available templates
      * @param page Pagination, starting at page 1
-     * @returns any OK
+     * @param limit Number of items per page
+     * @param sort List of fields to sort by
+     * @returns any The list of all templates given the parameters used
      * @throws ApiError
      */
-    templateList(page?: number): CancelablePromise<{
-        data: Array<DTOTemplateRead>;
+    templateList(page?: number, limit?: number, sort?: any[]): CancelablePromise<{
+        data?: Array<DTOTemplateRead>;
         pagination?: Pagination;
     }>;
     /**
-     * Create Template
-     * Create a new template
+     * Create a Template
+     * Creates a new Template
      * @param requestBody
-     * @returns DTOTemplateRead OK
+     * @returns DTOTemplateRead When a template is created
      * @throws ApiError
      */
     templateCreate(requestBody: DTOTemplateCreate): CancelablePromise<DTOTemplateRead>;
     /**
-     * Get Template
-     * Get a template via id
+     * Get Itinerary
+     * Get itinerary via ID
      * @param templateId Id of a template
-     * @returns DTOTemplateRead OK
+     * @returns any OK
      * @throws ApiError
      */
-    templateGet(templateId: string): CancelablePromise<DTOTemplateRead>;
+    itineraryGet(templateId: string): CancelablePromise<any>;
     /**
-     * Update Template
-     * Updates a template as a new revision
+     * Update Template as New Revision
+     * Updates an template as a new revision
      * @param templateId Id of a template
      * @param requestBody
-     * @returns DTOTemplateRead OK
+     * @returns DTOTemplateRead When a new revision is created successfully
      * @throws ApiError
      */
-    templateUpdate(templateId: string, requestBody: DTOTemplateUpdate): CancelablePromise<DTOTemplateRead>;
+    templateUpdateAsNewRevision(templateId: string, requestBody: DTOTemplateUpdate): CancelablePromise<DTOTemplateRead>;
     /**
-     * Delete Template
-     * Delete a template via id
+     * Delete Template via ID
+     * Deletes a specific template given its Id
      * @param templateId Id of a template
-     * @returns any OK
+     * @returns void
      * @throws ApiError
      */
-    templateDelete(templateId: string): CancelablePromise<any>;
+    templateDelete(templateId: string): CancelablePromise<void>;
     /**
-     * List components
-     * List all components
+     * List Component
+     * List all available component
      * @param page Pagination, starting at page 1
      * @param limit Number of items per page
-     * @returns any OK
+     * @param sort List of fields to sort by
+     * @returns any The list of all component given the parameters used
      * @throws ApiError
      */
-    componentList(page?: number, limit?: number): CancelablePromise<{
-        data: Array<DTOComponentRead>;
+    componentList(page?: number, limit?: number, sort?: any[]): CancelablePromise<{
+        data?: Array<DTOComponentRead>;
         pagination?: Pagination;
     }>;
     /**
-     * Create Component
-     * Create a new component
+     * Create a Component
+     * Creates a new Component
      * @param requestBody
-     * @returns DTOComponentRead OK
+     * @returns DTOComponentRead When a component is created
      * @throws ApiError
      */
     componentCreate(requestBody: DTOComponentCreate): CancelablePromise<DTOComponentRead>;
     /**
      * Get Component
-     * Get a component via id
+     * Get Component via ID
+     * @param componentId Id of a component
+     * @returns any OK
+     * @throws ApiError
+     */
+    componentGet(componentId: string): CancelablePromise<any>;
+    /**
+     * Update Component as New Revision
+     * Updates an component as a new revision
      * @param componentId Id of a component
-     * @returns DTOComponentRead OK
+     * @param requestBody
+     * @returns DTOComponentRead When a new component is created successfully
      * @throws ApiError
      */
-    componentGet(componentId: string): CancelablePromise<DTOComponentRead>;
+    componentUpdateAsNewRevision(componentId: string, requestBody: DTOComponentUpdate): CancelablePromise<DTOComponentRead>;
     /**
      * Update Component
-     * Update a component as a new revision
+     * Updates an component
      * @param componentId Id of a component
      * @param requestBody
-     * @returns DTOComponentRead OK
+     * @returns DTOComponentRead When a component is updated successfully
      * @throws ApiError
      */
     componentUpdate(componentId: string, requestBody: DTOComponentUpdate): CancelablePromise<DTOComponentRead>;
     /**
-     * Delete Component
-     * Delete a component via id
+     * Delete Component via ID
+     * Deletes a specific component given its Id
      * @param componentId Id of a component
-     * @returns any OK
+     * @returns void
      * @throws ApiError
      */
-    componentDelete(componentId: string): CancelablePromise<any>;
+    componentDelete(componentId: string): CancelablePromise<void>;
     /**
      * Update Component State
      * Directly update component state. This does not create a new revision