@microtronics/studio-cli 0.4.1 → 0.5.1

package/out/dde/fileGenerators/api.js

@@ -0,0 +1,551 @@
+"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 contextIdRef = { $ref: '#/components/parameters/contextId' };
+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
+        }
+    },
+    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));
+    }
+    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);
+        // legacy routes
+        generateLegacySchemasFromContainer(apiDescription, containerDefinition, context);
+        generateLegacyPathInformationFromContainer(apiDescription, containerDefinition);
+    }
+    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 = [];
+    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;
+    if (containerDefinition.containerType === ContainerType.hx) {
+        apiDescription.components.schemas[`${schemaName}Request`] = {
+            allOf: [
+                timeseriesRequestBaseRef,
+                {
+                    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(schema.properties)
+                            }
+                        }
+                    }
+                }
+            ]
+        };
+    }
+}
+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) {
+    const isTimeseriesContainer = containerDefinition.containerType === ContainerType.hx;
+    const containerType = isTimeseriesContainer ? 'timeseries' : 'containers';
+    const apiPath = `/api/1/sites/{siteUid}/${containerType}/${containerDefinition.title}`;
+    const apiPathMethods = {
+        get: undefined,
+        put: undefined
+    };
+    const getMethod = {
+        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.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: [tagNameFromContainerTitle(containerDefinition.title)],
+                summary: `Modify the data of the "${tagNameFromContainerTitle(containerDefinition.title)}" container`,
+                parameters: [contextIdRef],
+                requestBody: {
+                    content: {
+                        'application/json': {
+                            schema: {
+                                $ref: `#/components/schemas/${containerDefinition.title}`
+                            }
+                        }
+                    }
+                },
+                responses: {
+                    201: {
+                        ...successfulOperationResponse
+                    },
+                    204: {
+                        ...successfulOperationResponse
+                    },
+                    ...defaultResponseCodes
+                }
+            };
+        }
+        apiDescription.paths[apiPath] = apiPathMethods;
+    }
+    if (containerDefinition.containerType === ContainerType.hx) {
+        apiPathMethods.get = {
+            tags: [tagNameFromContainerTitle(containerDefinition.title)],
+            summary: `Get the historical data of "${containerDefinition.title}"`,
+            parameters: [
+                contextIdRef,
+                {
+                    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
+            }
+        };
+        apiDescription.paths[apiPath] = apiPathMethods;
+        const youngestPath = `${apiPath}/youngest`;
+        const youngestMethod = {
+            get: getMethod
+        };
+        youngestMethod.get.summary = `Get the youngest record of "${containerDefinition.title}" container`;
+        apiDescription.paths[youngestPath] = youngestMethod;
+        const oldestPath = `${apiPath}/oldest`;
+        const oldestMethod = {
+            get: getMethod
+        };
+        oldestMethod.get.summary = `Get the oldest record of "${containerDefinition.title}" container`;
+        apiDescription.paths[oldestPath] = oldestMethod;
+    }
+}
+//# sourceMappingURL=api.js.map

package/out/dde/fileGenerators/dlo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dlo.d.ts","sourceRoot":"","sources":["../../../src/dde/fileGenerators/dlo.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAE9C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG1C,OAAO,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC;AAUlC,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAqBxC,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,UA+LlH;AAED,qBAAa,gBAAgB;IAWhB,OAAO,CAAC,MAAM;IAAW,OAAO,CAAC,OAAO;IAVpD,OAAO,CAAC,eAAe,CAAgB;IACvC,OAAO,CAAC,gBAAgB,CAAgB;IACxC,OAAO,CAAC,gBAAgB,CAAgB;IACxC,OAAO,CAAC,gBAAgB,CAAgB;IACxC,OAAO,CAAC,eAAe,CAAgB;IACvC,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,oBAAoB,CAAgB;IAC5C,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,UAAU,CAA+F;gBAC7F,MAAM,EAAE,OAAO,EAAU,OAAO,EAAE,IAAI,GAAG,MAAM;IAGnE,OAAO,CAAC,IAAI;IAiBL,QAAQ;;;;IAoCf,OAAO,CAAC,eAAe;IAsBvB,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,gBAAgB;IAwBxB,OAAO,CAAC,8BAA8B;IAoEtC,OAAO,CAAC,uBAAuB;IAY/B,OAAO,CAAC,yBAAyB;IAgBjC,OAAO,CAAC,uBAAuB;IA8D/B,OAAO,CAAC,6BAA6B;IASrC,OAAO,CAAC,2BAA2B;IAmBnC;;;;;;OAMG;IACH,OAAO,CAAC,SAAS;IAcjB,OAAO,CAAC,0BAA0B;IA8BlC,OAAO,CAAC,mBAAmB;IAiD3B;;;;;;OAMG;IACH,OAAO,CAAC,4BAA4B;IAIpC,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,sBAAsB;IAmC9B,OAAO,CAAC,iBAAiB;IAoDzB;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;CA6B7B;AAGD,wBAAgB,4BAA4B,CAC3C,MAAM,EAAE,OAAO;AACf;;GAEG;AACH,gBAAgB,EAAE,MAAM,EAAE,UAsI1B;AAID,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,OAAO,UAqExD"}