dbgate-rest 7.1.3-alpha.2

package/lib/openApiAdapter.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyseOpenApiDefinition = void 0;
+/**
+ * Converts an OpenAPI v3.1 document into a simplified REST API definition
+ * Organizes endpoints by tags into categories
+ */
+function analyseOpenApiDefinition(doc) {
+    const categories = new Map();
+    // Process all paths and methods
+    if (doc.paths) {
+        for (const [path, pathItem] of Object.entries(doc.paths)) {
+            if (!pathItem)
+                continue;
+            // Process each HTTP method in the path
+            const methods = ['get', 'post', 'put', 'patch', 'delete', 'options', 'head', 'trace'];
+            for (const method of methods) {
+                const operation = pathItem[method];
+                if (!operation)
+                    continue;
+                const endpoint = {
+                    method: method.toUpperCase(),
+                    path,
+                    summary: operation.summary,
+                    description: operation.description,
+                    parameters: extractParameters(operation, pathItem),
+                };
+                // Use tags to organize into categories
+                const tags = operation.tags || ['Other'];
+                for (const tag of tags) {
+                    if (!categories.has(tag)) {
+                        categories.set(tag, []);
+                    }
+                    categories.get(tag).push(endpoint);
+                }
+            }
+        }
+    }
+    // Convert Map to RestApiCategory array
+    const categoryArray = Array.from(categories.entries()).map(([name, endpoints]) => ({
+        name,
+        endpoints,
+    }));
+    const servers = (doc.servers || []).map(server => ({
+        url: server.url,
+        description: server.description,
+    }));
+    return {
+        categories: categoryArray,
+        servers,
+    };
+}
+exports.analyseOpenApiDefinition = analyseOpenApiDefinition;
+/**
+ * Extract parameters from operation and path item
+ */
+function extractParameters(operation, pathItem) {
+    const parameters = [];
+    // Path item level parameters (apply to all methods)
+    if (pathItem.parameters) {
+        for (const param of pathItem.parameters) {
+            if (!('$ref' in param)) {
+                parameters.push(convertParameter(param));
+            }
+        }
+    }
+    // Operation level parameters
+    if (operation.parameters) {
+        for (const param of operation.parameters) {
+            if (!('$ref' in param)) {
+                parameters.push(convertParameter(param));
+            }
+        }
+    }
+    const bodyParameter = convertRequestBodyParameter(operation.requestBody);
+    if (bodyParameter) {
+        parameters.push(bodyParameter);
+    }
+    return parameters;
+}
+function isSchemaObject(schema) {
+    return !!schema && !('$ref' in schema);
+}
+function isExampleObject(example) {
+    return !!example && !('$ref' in example);
+}
+function cloneValue(value) {
+    if (value == null)
+        return value;
+    if (typeof value !== 'object')
+        return value;
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch (_a) {
+        return value;
+    }
+}
+function extractMediaTypeExample(mediaType) {
+    if (!mediaType)
+        return undefined;
+    if (mediaType.example !== undefined)
+        return cloneValue(mediaType.example);
+    if (mediaType.examples) {
+        const firstExample = Object.values(mediaType.examples)[0];
+        if (isExampleObject(firstExample) && firstExample.value !== undefined) {
+            return cloneValue(firstExample.value);
+        }
+    }
+    return undefined;
+}
+function buildSchemaExample(schema, recursionDepth = 0) {
+    var _a, _b, _c, _d, _e;
+    if (!schema || recursionDepth > 6)
+        return undefined;
+    if (schema.example !== undefined)
+        return cloneValue(schema.example);
+    if (schema.default !== undefined)
+        return cloneValue(schema.default);
+    if ((_a = schema.oneOf) === null || _a === void 0 ? void 0 : _a.length) {
+        const oneOfSchema = schema.oneOf[0];
+        return isSchemaObject(oneOfSchema) ? buildSchemaExample(oneOfSchema, recursionDepth + 1) : undefined;
+    }
+    if ((_b = schema.anyOf) === null || _b === void 0 ? void 0 : _b.length) {
+        const anyOfSchema = schema.anyOf[0];
+        return isSchemaObject(anyOfSchema) ? buildSchemaExample(anyOfSchema, recursionDepth + 1) : undefined;
+    }
+    if ((_c = schema.allOf) === null || _c === void 0 ? void 0 : _c.length) {
+        const mergedObject = {};
+        let hasValue = false;
+        for (const item of schema.allOf) {
+            if (!isSchemaObject(item))
+                continue;
+            const itemExample = buildSchemaExample(item, recursionDepth + 1);
+            if (itemExample && typeof itemExample === 'object' && !Array.isArray(itemExample)) {
+                Object.assign(mergedObject, itemExample);
+                hasValue = true;
+            }
+        }
+        return hasValue ? mergedObject : undefined;
+    }
+    if ((_d = schema.enum) === null || _d === void 0 ? void 0 : _d.length)
+        return cloneValue(schema.enum[0]);
+    if (schema.type === 'object' || schema.properties || schema.additionalProperties) {
+        const result = {};
+        let hasAnyProperty = false;
+        for (const [propertyName, propertySchema] of Object.entries(schema.properties || {})) {
+            if (!isSchemaObject(propertySchema))
+                continue;
+            const propertyValue = buildSchemaExample(propertySchema, recursionDepth + 1);
+            if (propertyValue !== undefined) {
+                result[propertyName] = propertyValue;
+                hasAnyProperty = true;
+            }
+        }
+        if (schema.additionalProperties) {
+            if (schema.additionalProperties === true) {
+                result.additionalProp1 = 'string';
+                hasAnyProperty = true;
+            }
+            else if (isSchemaObject(schema.additionalProperties)) {
+                result.additionalProp1 = (_e = buildSchemaExample(schema.additionalProperties, recursionDepth + 1)) !== null && _e !== void 0 ? _e : 'string';
+                hasAnyProperty = true;
+            }
+        }
+        return hasAnyProperty ? result : {};
+    }
+    if (schema.type === 'array') {
+        if (isSchemaObject(schema.items)) {
+            const itemValue = buildSchemaExample(schema.items, recursionDepth + 1);
+            return itemValue !== undefined ? [itemValue] : [];
+        }
+        return [];
+    }
+    if (schema.type === 'number' || schema.type === 'integer')
+        return 0;
+    if (schema.type === 'boolean')
+        return true;
+    if (schema.type === 'null')
+        return null;
+    return 'string';
+}
+function getSchemaType(schema) {
+    if (!schema)
+        return undefined;
+    if (schema.type === 'array') {
+        if (isSchemaObject(schema.items)) {
+            return `array<${schema.items.type || 'any'}>`;
+        }
+        return 'array';
+    }
+    if (Array.isArray(schema.type))
+        return schema.type.join(' | ');
+    if (schema.type)
+        return schema.type;
+    if (schema.properties)
+        return 'object';
+    return undefined;
+}
+function isStringListSchema(schema) {
+    return (schema === null || schema === void 0 ? void 0 : schema.type) === 'array' && isSchemaObject(schema.items) && schema.items.type === 'string';
+}
+function convertRequestBodyParameter(requestBody) {
+    if (!requestBody || '$ref' in requestBody || !requestBody.content)
+        return null;
+    const preferredContentTypes = [
+        'application/json',
+        'application/x-www-form-urlencoded',
+        'multipart/form-data',
+        'text/plain',
+    ];
+    const availableContentTypes = Object.keys(requestBody.content);
+    if (availableContentTypes.length === 0)
+        return null;
+    const selectedContentType = preferredContentTypes.find(contentType => { var _a; return (_a = requestBody.content) === null || _a === void 0 ? void 0 : _a[contentType]; }) || availableContentTypes[0];
+    const mediaType = requestBody.content[selectedContentType];
+    if (!mediaType || !isSchemaObject(mediaType.schema)) {
+        return {
+            name: 'body',
+            in: 'body',
+            contentType: selectedContentType,
+            description: requestBody.description,
+            required: requestBody.required,
+        };
+    }
+    const schema = mediaType.schema;
+    const mediaTypeExample = extractMediaTypeExample(mediaType);
+    const generatedExample = buildSchemaExample(schema);
+    return {
+        name: 'body',
+        in: 'body',
+        dataType: getSchemaType(schema),
+        contentType: selectedContentType,
+        isStringList: isStringListSchema(schema),
+        description: requestBody.description,
+        required: requestBody.required,
+        defaultValue: mediaTypeExample !== null && mediaTypeExample !== void 0 ? mediaTypeExample : generatedExample,
+    };
+}
+/**
+ * Convert OpenAPI parameter to REST API parameter
+ */
+function convertParameter(param) {
+    const schema = isSchemaObject(param.schema) ? param.schema : undefined;
+    return {
+        name: param.name,
+        in: param.in,
+        dataType: getSchemaType(schema),
+        isStringList: isStringListSchema(schema),
+        description: param.description,
+        required: param.required,
+        defaultValue: schema === null || schema === void 0 ? void 0 : schema.default,
+    };
+}

package/lib/openApiDriver.d.ts

@@ -0,0 +1,2 @@
+import type { EngineDriver } from 'dbgate-types';
+export declare const openApiDriver: EngineDriver;

package/lib/openApiDriver.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openApiDriver = void 0;
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const restDriverBase_1 = require("./restDriverBase");
+async function loadOpenApiDefinition(dbhan) {
+    var _a;
+    if (!((_a = dbhan === null || dbhan === void 0 ? void 0 : dbhan.connection) === null || _a === void 0 ? void 0 : _a.apiServerUrl1)) {
+        throw new Error('DBGM-00313 REST connection URL is not configured');
+    }
+    const response = await dbhan.axios.get(dbhan.connection.apiServerUrl1);
+    const content = response === null || response === void 0 ? void 0 : response.data;
+    let openApiDefinition = content;
+    if (typeof content === 'string') {
+        try {
+            openApiDefinition = JSON.parse(content);
+        }
+        catch (_b) {
+            openApiDefinition = js_yaml_1.default.load(content);
+        }
+    }
+    if (!openApiDefinition || typeof openApiDefinition !== 'object') {
+        throw new Error('DBGM-00314 API documentation is empty or could not be parsed');
+    }
+    return openApiDefinition;
+}
+// @ts-ignore
+exports.openApiDriver = {
+    ...restDriverBase_1.apiDriverBase,
+    engine: 'openapi@rest',
+    title: 'OpenAPI - REST',
+    databaseEngineTypes: ['rest', 'openapi'],
+    icon: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 128 128"><path fill="#85ea2d" d="M63.999 124.945c-33.607 0-60.95-27.34-60.95-60.949C3.05 30.388 30.392 3.048 64 3.048s60.95 27.342 60.95 60.95c0 33.607-27.343 60.946-60.95 60.946z"/><path fill="#173647" d="M40.3 43.311c-.198 2.19.072 4.454-.073 6.668-.173 2.217-.444 4.407-.888 6.596-.615 3.126-2.56 5.489-5.24 7.458 5.218 3.396 5.807 8.662 6.152 14.003.172 2.88.098 5.785.394 8.638.221 2.215 1.082 2.782 3.372 2.854.935.025 1.894 0 2.978 0v6.842c-6.768 1.156-12.354-.762-13.734-6.496a39.329 39.329 0 0 1-.836-6.4c-.148-2.287.097-4.577-.074-6.864-.492-6.277-1.305-8.393-7.308-8.689v-7.8c.441-.1.86-.174 1.302-.223 3.298-.172 4.701-1.182 5.414-4.43a37.512 37.512 0 0 0 .616-5.536c.247-3.569.148-7.21.763-10.754.86-5.094 4.01-7.556 9.254-7.852 1.476-.074 2.978 0 4.676 0v6.99c-.714.05-1.33.147-1.969.147-4.258-.148-4.48 1.304-4.8 4.848zm8.195 16.193h-.099c-2.462-.123-4.578 1.796-4.702 4.258-.122 2.485 1.797 4.603 4.259 4.724h.295c2.436.148 4.527-1.724 4.676-4.16v-.245c.05-2.486-1.944-4.527-4.43-4.577zm15.43 0c-2.386-.074-4.38 1.796-4.454 4.159 0 .149 0 .271.024.418 0 2.684 1.821 4.406 4.578 4.406 2.707 0 4.406-1.772 4.406-4.553-.025-2.682-1.823-4.455-4.554-4.43Zm15.801 0a4.596 4.596 0 0 0-4.676 4.454 4.515 4.515 0 0 0 4.528 4.528h.05c2.264.394 4.553-1.796 4.701-4.429.122-2.437-2.092-4.553-4.604-4.553Zm21.682.369c-2.855-.123-4.284-1.083-4.996-3.79a27.444 27.444 0 0 1-.811-5.292c-.198-3.298-.174-6.62-.395-9.918-.516-7.826-6.177-10.557-14.397-9.205v6.792c1.304 0 2.313 0 3.322.025 1.748.024 3.077.69 3.249 2.634.172 1.772.172 3.568.344 5.365.346 3.57.542 7.187 1.157 10.706.542 2.904 2.536 5.07 5.02 6.841-4.355 2.929-5.636 7.113-5.857 11.814-.122 3.223-.196 6.472-.368 9.721-.148 2.953-1.181 3.913-4.16 3.987-.835.024-1.648.098-2.583.148v6.964c1.748 0 3.347.1 4.946 0 4.971-.295 7.974-2.706 8.96-7.531.417-2.658.662-5.34.737-8.023.171-2.46.148-4.946.394-7.382.369-3.815 2.116-5.389 5.93-5.636a5.161 5.161 0 0 0 1.06-.245v-7.801c-.64-.074-1.084-.148-1.552-.173zM64 6.1c31.977 0 57.9 25.92 57.9 57.898 0 31.977-25.923 57.899-57.9 57.899-31.976 0-57.898-25.922-57.898-57.9C6.102 32.023 32.024 6.101 64 6.101m0-6.1C28.71 0 0 28.71 0 64c0 35.288 28.71 63.998 64 63.998 35.289 0 64-28.71 64-64S99.289.002 64 .002Z"/></svg>',
+    apiServerUrl1Label: 'API Definition URL',
+    apiServerUrl2Label: 'API Server URL',
+    apiServerUrl2Placeholder: '(optional - if not set, the first server URL from the API definition will be used)',
+    loadApiServerUrl2Options: true,
+    showConnectionField: (field, values) => {
+        if (restDriverBase_1.apiDriverBase.showAuthConnectionField(field, values))
+            return true;
+        if (field === 'apiServerUrl1')
+            return true;
+        if (field === 'apiServerUrl2')
+            return true;
+        return false;
+    },
+    beforeConnectionSave: connection => ({
+        ...connection,
+        singleDatabase: true,
+        defaultDatabase: '_api_database_',
+    }),
+    async connect(connection) {
+        return {
+            connection,
+            client: null,
+            database: '_api_database_',
+            axios: connection.axios
+        };
+    },
+    async listDatabases(dbhan) {
+        const openApiDefinition = await loadOpenApiDefinition(dbhan);
+        const servers = Array.isArray(openApiDefinition.servers) ? openApiDefinition.servers : [];
+        return servers
+            .map(server => { var _a; return String((_a = server === null || server === void 0 ? void 0 : server.url) !== null && _a !== void 0 ? _a : '').trim(); })
+            .filter(Boolean)
+            .map(url => ({
+            name: url,
+        }));
+    },
+    async getVersion(dbhan) {
+        var _a, _b, _c, _d;
+        const openApiDefinition = await loadOpenApiDefinition(dbhan);
+        const specVersion = String((_b = (_a = openApiDefinition.openapi) !== null && _a !== void 0 ? _a : openApiDefinition.swagger) !== null && _b !== void 0 ? _b : '').trim();
+        const apiVersion = String((_d = (_c = openApiDefinition.info) === null || _c === void 0 ? void 0 : _c.version) !== null && _d !== void 0 ? _d : '').trim();
+        const version = apiVersion || specVersion || 'Unknown';
+        const versionText = [
+            apiVersion ? `API ${apiVersion}` : null,
+            specVersion ? `OpenAPI ${specVersion}` : null,
+        ]
+            .filter(Boolean)
+            .join(', ');
+        return {
+            version,
+            ...(versionText ? { versionText } : {}),
+        };
+    },
+};

package/lib/restApiDef.d.ts

@@ -0,0 +1,55 @@
+export interface RestApiParameter {
+    name: string;
+    in: 'query' | 'header' | 'path' | 'cookie' | 'body';
+    dataType?: string;
+    contentType?: string;
+    isStringList?: boolean;
+    description?: string;
+    required?: boolean;
+    defaultValue?: any;
+    options?: Array<{
+        label: string;
+        value: string;
+    }>;
+    odataLookupPath?: string;
+    odataLookupEntitySet?: string;
+    odataLookupValueField?: string;
+    odataLookupLabelField?: string;
+}
+export interface RestApiEndpoint {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
+    path: string;
+    summary?: string;
+    description?: string;
+    parameters: RestApiParameter[];
+}
+export interface RestApiCategory {
+    name: string;
+    endpoints: RestApiEndpoint[];
+}
+export interface RestApiServer {
+    url: string;
+    description?: string;
+}
+export interface RestApiDefinition {
+    categories: RestApiCategory[];
+    servers?: RestApiServer[];
+}
+export interface RestApiAuthorization_None {
+    type: 'none';
+}
+export interface RestApiAuthorization_Basic {
+    type: 'basic';
+    user: string;
+    password: string;
+}
+export interface RestApiAuthorization_Bearer {
+    type: 'bearer';
+    token: string;
+}
+export interface RestApiAuthorization_ApiKey {
+    type: 'apikey';
+    header: string;
+    value: string;
+}
+export type RestApiAuthorization = RestApiAuthorization_None | RestApiAuthorization_Basic | RestApiAuthorization_Bearer | RestApiAuthorization_ApiKey;

package/lib/restApiDef.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/restApiExecutor.d.ts

@@ -0,0 +1,4 @@
+import type { AxiosInstance } from 'axios';
+import { RestApiAuthorization, RestApiDefinition } from './restApiDef';
+export declare function executeRestApiEndpointOpenApi(definition: RestApiDefinition, endpoint: string, method: string, parameterValues: Record<string, any>, server: string, auth: RestApiAuthorization | null, axios: AxiosInstance): Promise<any>;
+export declare function executeODataApiEndpoint(definition: RestApiDefinition, endpoint: string, method: string, parameterValues: Record<string, any>, server: string, auth: RestApiAuthorization | null, axios: AxiosInstance): Promise<any>;