swoop-common 2.1.49 → 2.1.51

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/bundler.js

@@ -1,29 +1,62 @@
 import fs from "fs";
-// Super lazy bundler, just sticks models onto the end of specs and updates refs
-const bundle = (sdk) => {
-    const specs = fs.readFileSync(`./openapi/${sdk}_service.yaml`, "utf-8");
-    const models = fs.readFileSync("./openapi/models.yaml", "utf-8");
-    // Remove header of models
-    const clean = models.split("\n");
-    let reached = false;
-    let full = "";
-    for (let i = 0; i < clean.length; i++) {
-        if (!reached && clean[i].startsWith("components"))
-            reached = true;
-        // Removes tags
-        if (clean[i].startsWith("tags"))
-            break;
-        if (reached)
-            full += "\n" + clean[i];
+import yaml from "js-yaml";
+/**
+ * Merge all `components` subsections (schemas, parameters, responses, etc.)
+ */
+function mergeComponents(target, source) {
+    if (!(source === null || source === void 0 ? void 0 : source.components))
+        return;
+    if (!target.components) {
+        target.components = {};
     }
-    // Dont need to parse specs, can just look for references
-    const updatedSpecs = specs.replace(/\.\/models\.yaml/g, "") + "\n" + full;
-    // Make sure all refs are wrapped in '
-    const cleanedSpecs = updatedSpecs.split("\n").map(line => line.replace(/(\$ref:\s*)(["']?)([^"'\s]+)\2/, (_, prefix, _q, path) => {
-        return `${prefix}'${path}'`;
-    })).join("\n");
+    for (const key of Object.keys(source.components)) {
+        if (!target.components[key]) {
+            target.components[key] = {};
+        }
+        Object.assign(target.components[key], source.components[key]);
+    }
+}
+/**
+ * Fix $ref pointers from external file refs (e.g. ./models.yaml#/...)
+ * to internal refs (#/components/...)
+ */
+function fixRefs(obj) {
+    if (Array.isArray(obj)) {
+        return obj.map(fixRefs);
+    }
+    else if (obj && typeof obj === "object") {
+        for (const key of Object.keys(obj)) {
+            if (key === "$ref" && typeof obj[key] === "string") {
+                obj[key] = obj[key]
+                    .replace("./models.yaml#", "#")
+                    .replace("./error.yaml#", "#");
+            }
+            else {
+                obj[key] = fixRefs(obj[key]);
+            }
+        }
+    }
+    return obj;
+}
+function bundle(sdk) {
+    const servicePath = `./openapi/${sdk}_service.yaml`;
+    const modelsPath = "./openapi/models.yaml";
+    const errorsPath = "./openapi/error.yaml";
+    const outputPath = `./openapi/generated/${sdk}_bundled.yaml`;
+    // Load YAML files
+    const service = yaml.load(fs.readFileSync(servicePath, "utf-8"));
+    const models = yaml.load(fs.readFileSync(modelsPath, "utf-8"));
+    const errors = yaml.load(fs.readFileSync(errorsPath, "utf-8"));
+    // Merge all components
+    mergeComponents(service, models);
+    mergeComponents(service, errors);
+    // Fix refs
+    const fixed = fixRefs(service);
+    // Dump back to YAML
+    const bundled = yaml.dump(fixed, { noRefs: true, lineWidth: -1 });
     fs.mkdirSync("./openapi/generated", { recursive: true });
-    fs.writeFileSync(`./openapi/generated/${sdk}_bundled.yaml`, cleanedSpecs);
-};
+    fs.writeFileSync(outputPath, bundled);
+    console.log(`✅ Bundled ${sdk} -> ${outputPath}`);
+}
 bundle("core");
 bundle("itinerary");

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/exports.d.ts

@@ -39,12 +39,14 @@ export type { DTOTemplateEntity } from './index';
 export type { DTOTemplateRead } from './index';
 export type { DTOTemplateUpdate } from './index';
 export type { enquiryId } from './index';
+export type { Error } from './index';
 export type { Fee } from './index';
 export type { Field } from './index';
 export type { IBEvent } from './index';
 export type { id } from './index';
 export type { itemsPerPage } from './index';
 export type { itineraryId } from './index';
+export type { itineraryIdQuery } from './index';
 export type { Limit } from './index';
 export { Meals } from './index';
 export type { Member } from './index';

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

@@ -41,12 +41,14 @@ export type { DTOTemplateEntity } from './models/DTOTemplateEntity';
 export type { DTOTemplateRead } from './models/DTOTemplateRead';
 export type { DTOTemplateUpdate } from './models/DTOTemplateUpdate';
 export type { enquiryId } from './models/enquiryId';
+export type { Error } from './models/Error';
 export type { Fee } from './models/Fee';
 export type { Field } from './models/Field';
 export type { IBEvent } from './models/IBEvent';
 export type { id } from './models/id';
 export type { itemsPerPage } from './models/itemsPerPage';
 export type { itineraryId } from './models/itineraryId';
+export type { itineraryIdQuery } from './models/itineraryIdQuery';
 export type { Limit } from './models/Limit';
 export { Meals } from './models/Meals';
 export type { Member } from './models/Member';
@@ -65,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,5 +1,4 @@
 export type DTOSnapshotCreate = {
     name: string;
     itineraryId: string;
-    enquiryId: string;
 };

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

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

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

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

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

@@ -0,0 +1 @@
+export type Error = Record<string, any>;

package/dist/api/generated/core/models/Error.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+/**
+ * Itinerary Id
+ */
+export type itineraryIdQuery = string;

package/dist/api/generated/core/models/itineraryIdQuery.js

@@ -0,0 +1 @@
+export {};

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`,
+            },
+        });
+    }
+}