@microtronics/studio-cli 0.60.0 → 0.62.0

package/out/dde/fileGenerators/api.js

@@ -1,688 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateAPIFromMap = generateAPIFromMap;
-const semver = __importStar(require("semver"));
-const yaml_1 = require("yaml");
-const coreDefinitions_1 = require("../coreDefinitions");
-var ContainerType = coreDefinitions_1.DDE_Core.ContainerType;
-var TransferDirection = coreDefinitions_1.DDE_Core.TransferDirection;
-var fieldTypeDefinitions = coreDefinitions_1.DDE_Core.fieldTypeDefinitions;
-const manifest_1 = require("../../manifest");
-const contextIdRef = { $ref: '#/components/parameters/contextId' };
-const addonIdRef = { $ref: '#/components/parameters/addonId' };
-const appIdRef = { $ref: '#/components/parameters/appId' };
-const histdataResponseRef = { $ref: '#/components/schemas/histdataResponse' };
-const histdataRequestRef = { $ref: '#/components/schemas/histdataRequest' };
-const rapidM2MStampRef = { $ref: '#/components/schemas/rapidM2MStamp' };
-const timeseriesRequestBaseRef = { $ref: '#/components/schemas/timeseriesRequestBase' };
-const RAPIDM2M_STAMP = 'rapidM2M Stamp';
-const successfulOperationResponse = {
-    description: 'Successful operation'
-};
-// default path context parameter
-const defaultComponents = {
-    parameters: {
-        contextId: {
-            name: 'siteUid',
-            in: 'path',
-            description: 'The site uid',
-            schema: {
-                type: 'string'
-            },
-            required: true
-        },
-        appId: {
-            name: 'appUid',
-            in: 'path',
-            description: 'The app uid',
-            schema: {
-                type: 'string'
-            },
-            required: true
-        }
-    },
-    schemas: {
-        rapidM2MStamp: {
-            type: 'string',
-            format: 'YYYYMMDDhhmmssSSS',
-            description: 'Special format of an UTC timestamp. Important: The trailing 0 are truncated. eg.: "2024-02-10" -> "2024021"'
-        }
-    }
-};
-const defaultAppComponents = {
-    ...structuredClone(defaultComponents)
-};
-Object.assign(defaultAppComponents.schemas, {
-    histdataResponse: {
-        type: 'array',
-        description: 'Array of histdata records. Array starts with the youngest record',
-        items: {
-            type: 'array',
-            description: 'First item is always the rapidM2M timestamp of the record. All following values are in the order of the "select" array.',
-            items: {
-                anyOf: [rapidM2MStampRef, { type: 'string' }, { type: 'number' }]
-            }
-        }
-    },
-    histdataRequest: {
-        type: 'object',
-        additionalProperties: false,
-        required: ['from', 'until'],
-        properties: {
-            from: {
-                type: 'string',
-                format: RAPIDM2M_STAMP,
-                description: 'items to include must be older or equal, UTC w/o time saving.'
-            },
-            until: {
-                type: 'string',
-                format: RAPIDM2M_STAMP,
-                description: 'items to include must be younger, UTC w/o time saving. Reply set is limited like that: from <= item.stamp < until.'
-            },
-            count: {
-                type: 'integer',
-                description: 'limits the number of returned records, negative values will count the records from the end of the result set.'
-            },
-            offset: {
-                type: 'integer',
-                description: 'skips the given number of records in the result set.'
-            }
-        }
-    },
-    timeseriesRequestBase: {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-            count: {
-                type: 'integer',
-                description: 'limits the number of returned records, negative values will count the records from the end of the result set.',
-                minimum: -1000,
-                maximum: 1000,
-                default: 1000
-            },
-            from: {
-                type: 'string',
-                format: RAPIDM2M_STAMP,
-                description: 'items to include must be older or equal, UTC w/o time saving'
-            },
-            until: {
-                type: 'string',
-                format: RAPIDM2M_STAMP,
-                description: 'items to include must be younger, UTC w/o time saving. Reply set is limited like that: from <= item.stamp < until'
-            },
-            offset: {
-                type: 'integer',
-                description: 'Skips the given number of records in the result set',
-                minimum: 0,
-                default: 0
-            }
-        }
-    }
-});
-const defaultErrorResponse = {
-    content: {
-        'application/json': {
-            schema: {
-                type: 'object',
-                additionalProperties: false,
-                properties: {
-                    err: {
-                        type: 'string',
-                        description: 'Information what went wrong'
-                    }
-                }
-            }
-        }
-    }
-};
-const defaultResponseCodes = {
-    401: {
-        description: 'Permission denied',
-        ...defaultErrorResponse
-    },
-    403: {
-        description: 'Forbidden',
-        ...defaultErrorResponse
-    },
-    404: {
-        description: 'Resource not found',
-        ...defaultErrorResponse
-    },
-    500: {
-        description: 'Internal error',
-        ...defaultErrorResponse
-    }
-};
-function generateAPIFromMap(ddeMap, manifest, context = null) {
-    const apiVersion = semver.coerce(manifest.version)?.version;
-    const apiDescription = {
-        openapi: '3.0.3',
-        info: { description: manifest.description, title: manifest.name, version: apiVersion || '' },
-        tags: [],
-        paths: {},
-        components: { parameters: {}, schemas: {} }
-    };
-    if (context) {
-        Object.assign(apiDescription.components, structuredClone(defaultComponents));
-    }
-    else {
-        Object.assign(apiDescription.components, structuredClone(defaultAppComponents));
-    }
-    const isAddon = manifest_1.Manifest.isAddon(manifest);
-    const isAnalytics = manifest_1.Manifest.isAnalytics(manifest);
-    if (isAddon) {
-        // add addonUid parameter if this is an addon project
-        apiDescription.components.parameters['addonId'] = {
-            name: 'addonUid',
-            in: 'path',
-            description: 'The addon uid',
-            schema: {
-                type: 'string'
-            },
-            required: true
-        };
-    }
-    for (const containerDefinition of Object.values(ddeMap.containers)) {
-        if ((context &&
-            (!containerDefinition.libraries.includes(context) || containerDefinition.containerType === ContainerType.hx)) ||
-            (!context && !coreDefinitions_1.DDE_Core.hasContainerAppFields(containerDefinition)) ||
-            containerDefinition.containerType === ContainerType.aloha) {
-            continue;
-        }
-        generateTagDescriptionFromContainer(apiDescription, containerDefinition);
-        generateSchemasFromContainer(apiDescription, containerDefinition, context);
-        generatePathInformationFromContainer(apiDescription, containerDefinition, isAddon, isAnalytics);
-        // legacy routes
-        if (!isAddon && !isAnalytics) {
-            generateLegacySchemasFromContainer(apiDescription, containerDefinition, context);
-            generateLegacyPathInformationFromContainer(apiDescription, containerDefinition);
-        }
-    }
-    apiDescription.tags.push({
-        name: 'app-center',
-        description: 'App Center related routes'
-    });
-    return (0, yaml_1.stringify)(apiDescription);
-}
-function generateTagDescriptionFromContainer(apiDescription, containerDefinition) {
-    apiDescription.tags.push({
-        name: tagNameFromContainerTitle(containerDefinition.title),
-        description: `Transfer direction ${containerDefinition.transferDirection}`
-    });
-}
-function tagNameFromContainerTitle(title) {
-    //todo maybe change to camelCase?
-    return title.split('_').join(' ');
-}
-function generateLegacySchemasFromContainer(apiDescription, containerDefinition, context) {
-    let schemaName = `${containerDefinition.name}`;
-    const schema = {
-        type: 'object',
-        description: `Container: "${containerDefinition.title}"`,
-        additionalProperties: false,
-        properties: {}
-    };
-    const requiredProperies = [];
-    // handle legacy histdata
-    if (containerDefinition.containerType === ContainerType.hx) {
-        schemaName += `Select`;
-        requiredProperies.push('select');
-        schema.properties['select'] = {
-            type: 'array',
-            items: {
-                type: 'string',
-                enum: []
-            }
-        };
-    }
-    for (const field of containerDefinition.fields) {
-        if (field.library !== context || field.type === 'shadow') {
-            continue;
-        }
-        if (containerDefinition.containerType === ContainerType.hx) {
-            schema.properties.select.items.enum.push(field.id);
-        }
-        else {
-            schema.properties[field.id] = getApiDefinitionForField(field);
-            // validate for read or write permission
-            if (!field.readPermission && !field.writePermission) {
-                requiredProperies.push(field.id);
-            }
-        }
-    }
-    schema.required = requiredProperies.length ? requiredProperies : undefined;
-    apiDescription.components.schemas[schemaName] = schema;
-}
-function generateSchemasFromContainer(apiDescription, containerDefinition, context = null) {
-    const schemaName = `${containerDefinition.title}`;
-    const schema = {
-        type: 'object',
-        description: `Container: "${containerDefinition.title}" with device transfer direction "${containerDefinition.transferDirection}"`,
-        additionalProperties: false,
-        properties: {}
-    };
-    const requiredProperties = [];
-    const isTimeseriesContainer = containerDefinition.containerType === ContainerType.hx;
-    for (const field of containerDefinition.fields) {
-        if (field.library !== context || field.type === 'shadow') {
-            continue;
-        }
-        schema.properties[field.name] = getApiDefinitionForField(field);
-        // validate for read or write permission
-        if (!field.readPermission && !field.writePermission) {
-            requiredProperties.push(field.name);
-        }
-    }
-    schema.required = requiredProperties.length ? requiredProperties : undefined;
-    apiDescription.components.schemas[schemaName] = schema;
-    const originalProperties = schema.properties;
-    if (isTimeseriesContainer) {
-        schema.required = schema.required?.map(name => name.toLowerCase());
-        const lowerCaseProperties = {};
-        for (const [key, value] of Object.entries(schema.properties)) {
-            lowerCaseProperties[key.toLowerCase()] = value;
-        }
-        schema.properties = lowerCaseProperties;
-    }
-    if (isTimeseriesContainer) {
-        const timerSeriesSelect = {
-            type: 'object',
-            description: `Request schema of "${containerDefinition.title}"`,
-            additionalProperties: false,
-            properties: {
-                select: {
-                    type: 'array',
-                    description: 'Optional selection of specific fields of the given container',
-                    items: {
-                        type: 'string',
-                        enum: Object.keys(originalProperties)
-                    }
-                }
-            }
-        };
-        apiDescription.components.schemas[`${schemaName}RequestSingle`] = timerSeriesSelect;
-        apiDescription.components.schemas[`${schemaName}Request`] = {
-            allOf: [timeseriesRequestBaseRef, timerSeriesSelect]
-        };
-        // stamp parameter is always returned if it is a timeseries container
-        schema.properties['stamp'] = rapidM2MStampRef;
-        requiredProperties.push('stamp');
-    }
-}
-function getApiDefinitionForField(field) {
-    const typeDefinition = fieldTypeDefinitions[field.type];
-    const schemaDefinition = { ...typeDefinition.openApi };
-    const defaultValue = parseDefaultValueFromField(field);
-    schemaDefinition.default = defaultValue;
-    schemaDefinition.example = defaultValue;
-    schemaDefinition.description = field.description;
-    return schemaDefinition;
-}
-function parseDefaultValueFromField(field) {
-    if (field.defaultValue === undefined) {
-        return field.defaultValue;
-    }
-    if (field.type === 'binary') {
-        return `${field.defaultValue.substring(2)}`;
-    }
-    return field.defaultValue;
-}
-function generateLegacyPathInformationFromContainer(apiDescription, containerDefinition) {
-    let apiPath = `/api/1/sites/{siteUid}/${containerDefinition.name}`;
-    const apiPathMethods = {
-        get: undefined,
-        put: undefined
-    };
-    if ([ContainerType.cx, ContainerType.cb].includes(containerDefinition.containerType)) {
-        // add get methods
-        apiPathMethods.get = {
-            deprecated: true,
-            tags: [tagNameFromContainerTitle(containerDefinition.title)],
-            summary: `Retrieve the data of the "${tagNameFromContainerTitle(containerDefinition.title)}" container`,
-            parameters: [contextIdRef],
-            responses: {
-                '200': {
-                    ...successfulOperationResponse,
-                    content: {
-                        'application/json': {
-                            schema: {
-                                allOf: [
-                                    {
-                                        type: 'object',
-                                        required: ['stamp'],
-                                        properties: {
-                                            stamp: rapidM2MStampRef
-                                        }
-                                    },
-                                    {
-                                        $ref: `#/components/schemas/${containerDefinition.name}`
-                                    }
-                                ]
-                            }
-                        }
-                    }
-                },
-                ...defaultResponseCodes
-            }
-        };
-        if ([TransferDirection.down, TransferDirection.backendOnly].includes(containerDefinition.transferDirection)) {
-            apiPathMethods.put = {
-                deprecated: true,
-                tags: [tagNameFromContainerTitle(containerDefinition.title)],
-                summary: `Modify the data of the "${tagNameFromContainerTitle(containerDefinition.title)}" container`,
-                parameters: [contextIdRef],
-                requestBody: {
-                    content: {
-                        'application/json': {
-                            schema: {
-                                $ref: `#/components/schemas/${containerDefinition.name}`
-                            }
-                        }
-                    }
-                },
-                responses: {
-                    201: {
-                        ...successfulOperationResponse
-                    },
-                    204: {
-                        ...successfulOperationResponse
-                    },
-                    ...defaultResponseCodes
-                }
-            };
-        }
-    }
-    else if (containerDefinition.containerType === ContainerType.hx) {
-        const timeSeriesPath = `${apiPath}`;
-        // youngest histdata record:
-        apiPath += `/youngest`;
-        apiPathMethods.get = {
-            deprecated: true,
-            tags: [tagNameFromContainerTitle(containerDefinition.title)],
-            summary: `Retrieve the youngest data of the "${tagNameFromContainerTitle(containerDefinition.title)}" container`,
-            parameters: [
-                contextIdRef,
-                {
-                    name: 'json',
-                    in: 'query',
-                    required: true,
-                    schema: {
-                        $ref: `#/components/schemas/${containerDefinition.name}Select`
-                    }
-                }
-            ],
-            responses: {
-                '200': {
-                    ...successfulOperationResponse,
-                    content: {
-                        'application/json': {
-                            schema: histdataResponseRef
-                        }
-                    }
-                },
-                ...defaultResponseCodes
-            }
-        };
-        apiDescription.paths[timeSeriesPath] = {
-            get: {
-                deprecated: true,
-                tags: [tagNameFromContainerTitle(containerDefinition.title)],
-                summary: `Get the historical data of the "${tagNameFromContainerTitle(containerDefinition.title)}" container.`,
-                parameters: [
-                    contextIdRef,
-                    {
-                        name: 'json',
-                        in: 'query',
-                        required: true,
-                        schema: {
-                            allOf: [{ $ref: `#/components/schemas/${containerDefinition.name}Select` }, histdataRequestRef]
-                        }
-                    }
-                ],
-                responses: {
-                    '200': {
-                        ...successfulOperationResponse,
-                        content: {
-                            'application/json': {
-                                schema: histdataResponseRef
-                            }
-                        }
-                    },
-                    ...defaultResponseCodes
-                }
-            }
-        };
-    }
-    apiDescription.paths[apiPath] = apiPathMethods;
-}
-function generatePathInformationFromContainer(apiDescription, containerDefinition, isAddonProject = false, isAnalyticsProject = false) {
-    const isTimeseriesContainer = containerDefinition.containerType === ContainerType.hx;
-    const containerType = isTimeseriesContainer ? 'timeseries' : 'containers';
-    let apiPathOptions = [];
-    const containerRouteTagName = tagNameFromContainerTitle(containerDefinition.title);
-    // analytic projects do not have any site
-    if (!isAnalyticsProject) {
-        apiPathOptions.push({
-            path: `/api/1/sites/{siteUid}/${containerType}/${containerDefinition.title}`,
-            params: [contextIdRef],
-            tags: [containerRouteTagName]
-        });
-    }
-    if (isAddonProject) {
-        apiPathOptions = [
-            {
-                path: `/api/1/sites/{siteUid}/addons/{addonUid}/${containerType}/${containerDefinition.title}`,
-                params: [contextIdRef, addonIdRef],
-                tags: [containerRouteTagName]
-            }
-        ];
-    }
-    const appCenterPathOptions = {
-        path: `/api/1/app-center/apps/{appUid}/${containerType}/${containerDefinition.title}`,
-        params: [appIdRef],
-        tags: ['app-center']
-    };
-    if (isAnalyticsProject) {
-        appCenterPathOptions.tags.push(containerRouteTagName);
-    }
-    apiPathOptions.push(appCenterPathOptions);
-    const apiPathMethods = {
-        get: undefined,
-        put: undefined,
-        post: undefined
-    };
-    const getMethod = {
-        tags: [],
-        summary: `Retrieve the data of the "${tagNameFromContainerTitle(containerDefinition.title)}" container`,
-        parameters: [],
-        responses: {
-            '200': {
-                ...successfulOperationResponse,
-                content: {
-                    'application/json': {
-                        schema: {
-                            allOf: [
-                                {
-                                    type: 'object',
-                                    required: ['stamp'],
-                                    properties: {
-                                        stamp: rapidM2MStampRef
-                                    }
-                                },
-                                {
-                                    $ref: `#/components/schemas/${containerDefinition.title}`
-                                }
-                            ]
-                        }
-                    }
-                }
-            },
-            ...defaultResponseCodes
-        }
-    };
-    if ([ContainerType.cx, ContainerType.cb].includes(containerDefinition.containerType)) {
-        // add get methods
-        apiPathMethods.get = getMethod;
-        if ([TransferDirection.down, TransferDirection.backendOnly].includes(containerDefinition.transferDirection)) {
-            apiPathMethods.put = {
-                tags: [],
-                summary: `Modify the data of the "${tagNameFromContainerTitle(containerDefinition.title)}" container`,
-                parameters: [],
-                requestBody: {
-                    content: {
-                        'application/json': {
-                            schema: {
-                                $ref: `#/components/schemas/${containerDefinition.title}`
-                            }
-                        }
-                    }
-                },
-                responses: {
-                    201: {
-                        ...successfulOperationResponse
-                    },
-                    204: {
-                        ...successfulOperationResponse
-                    },
-                    ...defaultResponseCodes
-                }
-            };
-        }
-        apiPathOptions.forEach(path => {
-            const methods = structuredClone(apiPathMethods);
-            Object.values(methods).forEach(value => {
-                value?.parameters?.unshift(...path.params);
-                value?.tags?.unshift(...path.tags);
-            });
-            apiDescription.paths[path.path] = methods;
-        });
-    }
-    if (containerDefinition.containerType === ContainerType.hx) {
-        apiPathMethods.get = {
-            tags: [],
-            summary: `Get the historical data of "${containerDefinition.title}"`,
-            parameters: [
-                {
-                    name: 'json',
-                    in: 'query',
-                    required: false,
-                    schema: {
-                        $ref: `#/components/schemas/${containerDefinition.title}Request`
-                    }
-                }
-            ],
-            responses: {
-                '200': {
-                    ...successfulOperationResponse,
-                    content: {
-                        'application/json': {
-                            schema: {
-                                type: 'array',
-                                items: {
-                                    $ref: `#/components/schemas/${containerDefinition.title}`
-                                }
-                            }
-                        }
-                    }
-                },
-                ...defaultResponseCodes
-            }
-        };
-        if (isAddonProject) {
-            apiPathMethods.post = {
-                tags: [],
-                summary: `Insert data into the "${tagNameFromContainerTitle(containerDefinition.title)}" container`,
-                parameters: [
-                    {
-                        name: 'allow_future_date',
-                        in: 'query',
-                        description: 'Allow inserting records with a stamp value in the future',
-                        schema: {
-                            type: 'boolean'
-                        }
-                    }
-                ],
-                requestBody: {
-                    content: {
-                        'application/json': {
-                            schema: {
-                                $ref: `#/components/schemas/${containerDefinition.title}`
-                            }
-                        }
-                    }
-                },
-                responses: {
-                    201: {
-                        ...successfulOperationResponse
-                    },
-                    400: {
-                        description: 'Bad request',
-                        ...defaultErrorResponse
-                    },
-                    ...defaultResponseCodes
-                }
-            };
-        }
-        // only site and addons support timeseries
-        const pathOptions = apiPathOptions[0];
-        const methods = structuredClone(apiPathMethods);
-        Object.values(methods).forEach(value => {
-            value?.parameters?.unshift(...pathOptions.params);
-            value?.tags?.unshift(...pathOptions.tags);
-        });
-        apiDescription.paths[pathOptions.path] = methods;
-        const histdataSingleResponse = {
-            ...successfulOperationResponse,
-            content: {
-                'application/json': {
-                    schema: {
-                        $ref: `#/components/schemas/${containerDefinition.title}`
-                    }
-                }
-            }
-        };
-        const youngestPath = `${pathOptions.path}/youngest`;
-        const youngestMethod = {
-            get: structuredClone(methods.get)
-        };
-        youngestMethod.get.summary = `Get the youngest record of "${containerDefinition.title}" container`;
-        youngestMethod.get.responses['200'] = histdataSingleResponse;
-        const parameterIdx = isAddonProject ? 2 : 1;
-        youngestMethod.get.parameters[parameterIdx].schema.$ref =
-            `#/components/schemas/${containerDefinition.title}RequestSingle`;
-        apiDescription.paths[youngestPath] = youngestMethod;
-        const oldestPath = `${pathOptions.path}/oldest`;
-        const oldestMethod = {
-            get: structuredClone(methods.get)
-        };
-        oldestMethod.get.summary = `Get the oldest record of "${containerDefinition.title}" container`;
-        oldestMethod.get.responses['200'] = histdataSingleResponse;
-        oldestMethod.get.parameters[parameterIdx].schema.$ref =
-            `#/components/schemas/${containerDefinition.title}RequestSingle`;
-        apiDescription.paths[oldestPath] = oldestMethod;
-    }
-}
-//# sourceMappingURL=api.js.map