dbgate-rest 7.1.3-alpha.2

package/lib/restApiExecutor.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeODataApiEndpoint = exports.executeRestApiEndpointOpenApi = void 0;
+function hasValue(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (typeof value === 'string')
+        return value.trim() !== '';
+    if (Array.isArray(value))
+        return value.length > 0;
+    return true;
+}
+function normalizeValueForRequest(value, parameter) {
+    if (!hasValue(value))
+        return undefined;
+    if (parameter.isStringList) {
+        if (Array.isArray(value))
+            return value.filter(item => item != null && String(item).trim() !== '');
+        return [String(value)];
+    }
+    if (parameter.in === 'body' && typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return undefined;
+        if ((parameter.contentType || '').includes('json') || parameter.dataType === 'object') {
+            try {
+                return JSON.parse(trimmed);
+            }
+            catch (_a) {
+                return value;
+            }
+        }
+    }
+    return value;
+}
+function splitPathAndQuery(path) {
+    const value = String(path || '');
+    const index = value.indexOf('?');
+    if (index < 0) {
+        return {
+            pathOnly: value,
+            queryString: '',
+        };
+    }
+    return {
+        pathOnly: value.slice(0, index),
+        queryString: value.slice(index + 1),
+    };
+}
+function addAuthHeaders(headers, auth) {
+    if (!auth)
+        return;
+    if (auth.type === 'basic') {
+        const basicAuth = Buffer.from(`${auth.user}:${auth.password}`).toString('base64');
+        headers['Authorization'] = `Basic ${basicAuth}`;
+    }
+    else if (auth.type === 'bearer') {
+        headers['Authorization'] = `Bearer ${auth.token}`;
+    }
+    else if (auth.type === 'apikey') {
+        headers[auth.header] = auth.value;
+    }
+}
+function findEndpointDefinition(definition, endpoint, method) {
+    return definition.categories
+        .flatMap(category => category.endpoints)
+        .find(ep => ep.path === endpoint && ep.method === method);
+}
+function buildRequestUrl(server, pathOnly) {
+    const normalizedServer = String(server || '').trim();
+    const normalizedPath = String(pathOnly || '').trim();
+    if (!normalizedServer) {
+        return normalizedPath;
+    }
+    try {
+        const baseUrl = normalizedServer.endsWith('/') ? normalizedServer : `${normalizedServer}/`;
+        const relativePath = normalizedPath.replace(/^\//, '');
+        return new URL(relativePath, baseUrl).toString();
+    }
+    catch (_a) {
+        return normalizedServer + normalizedPath;
+    }
+}
+function appendQueryAndCookies(url, query, cookies, headers) {
+    const queryStringValue = query.toString();
+    if (queryStringValue) {
+        const separator = url.includes('?') ? '&' : '?';
+        url += separator + queryStringValue;
+    }
+    if (cookies.length > 0) {
+        headers['Cookie'] = cookies.join('; ');
+    }
+    return url;
+}
+const ODATA_SYSTEM_QUERY_OPTIONS = new Set([
+    '$filter',
+    '$select',
+    '$expand',
+    '$orderby',
+    '$top',
+    '$skip',
+    '$count',
+    '$search',
+    '$format',
+]);
+const ODATA_SYSTEM_QUERY_ALIASES = {
+    filter: '$filter',
+    select: '$select',
+    expand: '$expand',
+    orderby: '$orderby',
+    top: '$top',
+    skip: '$skip',
+    count: '$count',
+    search: '$search',
+    format: '$format',
+};
+function resolveODataQueryOptionKey(rawKey) {
+    const key = String(rawKey || '').trim();
+    if (!key)
+        return null;
+    const keyLower = key.toLowerCase();
+    if (ODATA_SYSTEM_QUERY_OPTIONS.has(keyLower)) {
+        return keyLower;
+    }
+    return ODATA_SYSTEM_QUERY_ALIASES[keyLower] || null;
+}
+function normalizeODataQueryOptionValue(optionKey, value) {
+    if (!hasValue(value))
+        return null;
+    if (Array.isArray(value)) {
+        const items = value.filter(item => hasValue(item)).map(item => String(item).trim()).filter(Boolean);
+        if (items.length === 0)
+            return null;
+        return items.join(',');
+    }
+    if (optionKey === '$count') {
+        if (typeof value === 'boolean')
+            return value ? 'true' : 'false';
+        const lowered = String(value).trim().toLowerCase();
+        if (lowered === 'true' || lowered === 'false')
+            return lowered;
+        return null;
+    }
+    if (optionKey === '$top' || optionKey === '$skip') {
+        const numeric = Number(value);
+        if (Number.isFinite(numeric) && numeric >= 0) {
+            return String(Math.trunc(numeric));
+        }
+        return null;
+    }
+    return String(value).trim();
+}
+function applyODataSystemQueryOptions(query, parameterValues) {
+    for (const [rawKey, rawValue] of Object.entries(parameterValues || {})) {
+        const optionKey = resolveODataQueryOptionKey(rawKey);
+        if (!optionKey)
+            continue;
+        const normalizedValue = normalizeODataQueryOptionValue(optionKey, rawValue);
+        if (!hasValue(normalizedValue))
+            continue;
+        query.set(optionKey, String(normalizedValue));
+    }
+}
+async function executeRestApiEndpointOpenApi(definition, endpoint, method, parameterValues, server, auth, axios) {
+    const endpointDef = findEndpointDefinition(definition, endpoint, method);
+    if (!endpointDef) {
+        throw new Error(`Endpoint ${method} ${endpoint} not found in definition.`);
+    }
+    const { pathOnly, queryString } = splitPathAndQuery(endpointDef.path);
+    let url = buildRequestUrl(server, pathOnly);
+    const headers = {};
+    const query = new URLSearchParams(queryString);
+    const cookies = [];
+    let body = undefined;
+    for (const param of endpointDef.parameters) {
+        const value = normalizeValueForRequest(parameterValues[param.name], param);
+        if (!hasValue(value) && param.in !== 'path') {
+            continue;
+        }
+        if (param.in === 'path') {
+            url = url.replace(`{${param.name}}`, encodeURIComponent(value));
+        }
+        else if (param.in === 'query') {
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    query.append(param.name, String(item));
+                }
+            }
+            else {
+                query.append(param.name, String(value));
+            }
+        }
+        else if (param.in === 'header') {
+            headers[param.name] = Array.isArray(value) ? value.map(item => String(item)).join(',') : String(value);
+        }
+        else if (param.in === 'cookie') {
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    cookies.push(`${encodeURIComponent(param.name)}=${encodeURIComponent(String(item))}`);
+                }
+            }
+            else {
+                cookies.push(`${encodeURIComponent(param.name)}=${encodeURIComponent(String(value))}`);
+            }
+        }
+        else if (param.in === 'body') {
+            body = value;
+            if (param.contentType && !headers['Content-Type']) {
+                headers['Content-Type'] = param.contentType;
+            }
+        }
+    }
+    url = appendQueryAndCookies(url, query, cookies, headers);
+    addAuthHeaders(headers, auth);
+    const resp = await axios({
+        method,
+        url,
+        headers,
+        data: body,
+    });
+    return resp;
+}
+exports.executeRestApiEndpointOpenApi = executeRestApiEndpointOpenApi;
+async function executeODataApiEndpoint(definition, endpoint, method, parameterValues, server, auth, axios) {
+    const endpointDef = findEndpointDefinition(definition, endpoint, method);
+    if (!endpointDef) {
+        throw new Error(`Endpoint ${method} ${endpoint} not found in definition.`);
+    }
+    const { pathOnly, queryString } = splitPathAndQuery(endpointDef.path);
+    const metadataPath = pathOnly.replace(/\/+$/, '') === '/$metadata';
+    let url = buildRequestUrl(server, pathOnly);
+    const headers = {
+        Accept: 'application/json',
+        'OData-Version': '4.0',
+    };
+    const query = metadataPath ? new URLSearchParams() : new URLSearchParams(queryString);
+    const cookies = [];
+    let body = undefined;
+    for (const param of endpointDef.parameters) {
+        const value = normalizeValueForRequest(parameterValues[param.name], param);
+        if (!hasValue(value) && param.in !== 'path') {
+            continue;
+        }
+        if (param.in === 'path') {
+            url = url.replace(`{${param.name}}`, encodeURIComponent(value));
+        }
+        else if (param.in === 'query') {
+            if (metadataPath)
+                continue;
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    query.append(param.name, String(item));
+                }
+            }
+            else {
+                query.append(param.name, String(value));
+            }
+        }
+        else if (param.in === 'header') {
+            headers[param.name] = Array.isArray(value) ? value.map(item => String(item)).join(',') : String(value);
+        }
+        else if (param.in === 'cookie') {
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    cookies.push(`${encodeURIComponent(param.name)}=${encodeURIComponent(String(item))}`);
+                }
+            }
+            else {
+                cookies.push(`${encodeURIComponent(param.name)}=${encodeURIComponent(String(value))}`);
+            }
+        }
+        else if (param.in === 'body') {
+            body = value;
+            if (param.contentType && !headers['Content-Type']) {
+                headers['Content-Type'] = param.contentType;
+            }
+        }
+    }
+    if (!metadataPath) {
+        applyODataSystemQueryOptions(query, parameterValues);
+    }
+    url = appendQueryAndCookies(url, query, cookies, headers);
+    addAuthHeaders(headers, auth);
+    const resp = await axios({
+        method,
+        url,
+        headers,
+        data: body,
+    });
+    return resp;
+}
+exports.executeODataApiEndpoint = executeODataApiEndpoint;

package/lib/restApiExecutor.test.d.ts

@@ -0,0 +1,16 @@
+declare const executeODataApiEndpoint: any;
+declare function createDefinition(): {
+    categories: {
+        name: string;
+        endpoints: {
+            method: string;
+            path: string;
+            parameters: {
+                name: string;
+                in: string;
+                dataType: string;
+                required: boolean;
+            }[];
+        }[];
+    }[];
+};

package/lib/restApiExecutor.test.js

@@ -0,0 +1,99 @@
+const { executeODataApiEndpoint } = require('./restApiExecutor');
+function createDefinition() {
+    return {
+        categories: [
+            {
+                name: 'EntitySet',
+                endpoints: [
+                    {
+                        method: 'GET',
+                        path: '/customers',
+                        parameters: [
+                            {
+                                name: 'company',
+                                in: 'query',
+                                dataType: 'string',
+                                required: true,
+                            },
+                        ],
+                    },
+                    {
+                        method: 'GET',
+                        path: '/$metadata',
+                        parameters: [],
+                    },
+                ],
+            },
+        ],
+    };
+}
+test('adds OData system query options from parameterValues', async () => {
+    const calls = [];
+    const axios = async (args) => {
+        calls.push(args);
+        return { status: 200, data: {} };
+    };
+    await executeODataApiEndpoint(createDefinition(), '/customers', 'GET', {
+        company: '123',
+        '$top': 50,
+        '$skip': '10',
+        '$count': true,
+        '$select': ['id', 'displayName'],
+        '$orderby': 'displayName asc',
+        '$filter': 'displayName ne null',
+        '$search': 'dino',
+        '$expand': 'addresses',
+        '$format': 'application/json',
+    }, 'https://example.test/odata', null, axios);
+    expect(calls).toHaveLength(1);
+    const requestUrl = String(calls[0].url);
+    const parsed = new URL(requestUrl);
+    expect(parsed.pathname).toBe('/odata/customers');
+    expect(parsed.searchParams.get('company')).toBe('123');
+    expect(parsed.searchParams.get('$top')).toBe('50');
+    expect(parsed.searchParams.get('$skip')).toBe('10');
+    expect(parsed.searchParams.get('$count')).toBe('true');
+    expect(parsed.searchParams.get('$select')).toBe('id,displayName');
+    expect(parsed.searchParams.get('$orderby')).toBe('displayName asc');
+    expect(parsed.searchParams.get('$filter')).toBe('displayName ne null');
+    expect(parsed.searchParams.get('$search')).toBe('dino');
+    expect(parsed.searchParams.get('$expand')).toBe('addresses');
+    expect(parsed.searchParams.get('$format')).toBe('application/json');
+});
+test('accepts non-dollar aliases and ignores invalid system option values', async () => {
+    const calls = [];
+    const axios = async (args) => {
+        calls.push(args);
+        return { status: 200, data: {} };
+    };
+    await executeODataApiEndpoint(createDefinition(), '/customers', 'GET', {
+        company: '123',
+        top: 'abc',
+        skip: -1,
+        count: 'yes',
+        select: ['id'],
+        filter: 'id ne null',
+    }, 'https://example.test/odata', null, axios);
+    expect(calls).toHaveLength(1);
+    const parsed = new URL(String(calls[0].url));
+    expect(parsed.searchParams.get('$top')).toBeNull();
+    expect(parsed.searchParams.get('$skip')).toBeNull();
+    expect(parsed.searchParams.get('$count')).toBeNull();
+    expect(parsed.searchParams.get('$select')).toBe('id');
+    expect(parsed.searchParams.get('$filter')).toBe('id ne null');
+});
+test('does not add OData system query options to $metadata endpoint', async () => {
+    const calls = [];
+    const axios = async (args) => {
+        calls.push(args);
+        return { status: 200, data: {} };
+    };
+    await executeODataApiEndpoint(createDefinition(), '/$metadata', 'GET', {
+        '$top': 10,
+        '$count': true,
+    }, 'https://example.test/odata', null, axios);
+    expect(calls).toHaveLength(1);
+    const parsed = new URL(String(calls[0].url));
+    expect(parsed.pathname).toBe('/odata/$metadata');
+    expect(parsed.search).toBe('');
+});

package/lib/restAuthTools.d.ts

@@ -0,0 +1,2 @@
+import { RestApiAuthorization } from './restApiDef';
+export declare function buildRestAuthHeaders(auth: RestApiAuthorization | null): {};

package/lib/restAuthTools.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRestAuthHeaders = void 0;
+function buildRestAuthHeaders(auth) {
+    const headers = {};
+    if (!auth)
+        return headers;
+    if (auth.type === 'basic') {
+        const basicAuth = Buffer.from(`${auth.user}:${auth.password}`).toString('base64');
+        headers['Authorization'] = `Basic ${basicAuth}`;
+    }
+    else if (auth.type === 'bearer') {
+        headers['Authorization'] = `Bearer ${auth.token}`;
+    }
+    else if (auth.type === 'apikey') {
+        headers[auth.header] = auth.value;
+    }
+    return headers;
+}
+exports.buildRestAuthHeaders = buildRestAuthHeaders;

package/lib/restDriverBase.d.ts

@@ -0,0 +1,61 @@
+export declare const apiDriverBase: {
+    supportExecuteQuery: boolean;
+    getAuthTypes(): {
+        title: string;
+        name: string;
+    }[];
+    showAuthConnectionField: (field: any, values: any) => boolean;
+    analyserClass: any;
+    dumperClass: typeof import("dbgate-tools").SqlDumper;
+    dialect: {
+        limitSelect: boolean;
+        rangeSelect: boolean;
+        topRecords: boolean;
+        offsetFetchRangeSyntax: boolean;
+        stringEscapeChar: string;
+        fallbackDataType: string;
+        quoteIdentifier(s: any): any;
+        columnProperties: {
+            isSparse: boolean;
+            isPersisted: boolean;
+        };
+        defaultSchemaName: any;
+    };
+    databaseEngineTypes: string[];
+    supportedCreateDatabase: boolean;
+    analyseFull(pool: any, version: any): Promise<any>;
+    analyseSingleObject(pool: any, name: any, typeField?: string): Promise<any>;
+    analyseSingleTable(pool: any, name: any): any;
+    analyseIncremental(pool: any, structure: any, version: any): Promise<any>;
+    createDumper(options?: any): import("dbgate-tools").SqlDumper;
+    script(pool: any, sql: any, options: import("dbgate-types").RunScriptOptions): Promise<void>;
+    operation(pool: any, operation: any, options: import("dbgate-types").RunScriptOptions): Promise<void>;
+    getNewObjectTemplates(): {
+        label: string;
+        sql: string;
+    }[];
+    loadFieldValues(pool: any, name: any, columnName: any, search: any, dataType: any): Promise<any>;
+    readJsonQuery(pool: any, select: any, structure: any): any;
+    showConnectionField: (field: any, values: any) => boolean;
+    showConnectionTab: (field: any) => boolean;
+    getAccessTokenFromAuth: (connection: any, req: any) => Promise<any>;
+    getFilterBehaviour(dataType: string, standardFilterBehaviours: any): import("dbgate-types").FilterBehaviour;
+    getCollectionExportQueryScript(collection: string, condition: any, sort: any): any;
+    getCollectionExportQueryJson(collection: string, condition: any, sort: any): any;
+    getScriptTemplates(objectTypeField: any): any[];
+    getScriptTemplateContent(scriptTemplate: any, props: any): any;
+    dataEditorTypesBehaviour: {
+        parseSqlNull: boolean;
+        parseHexAsBuffer: boolean;
+    };
+    createSaveChangeSetScript(changeSet: any, dbinfo: any, defaultCreator: any): any;
+    adaptDataType(dataType: string): string;
+    adaptTableInfo(table: any): any;
+    listSchemas(pool: any): Promise<any>;
+    writeQueryFromStream(dbhan: any, sql: any): Promise<any>;
+    getLogDbInfo(dbhan: any): {
+        database: any;
+        engine: any;
+        conid: any;
+    };
+};

package/lib/restDriverBase.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiDriverBase = void 0;
+const dbgate_tools_1 = require("dbgate-tools");
+exports.apiDriverBase = {
+    ...dbgate_tools_1.driverBase,
+    supportExecuteQuery: false,
+    getAuthTypes() {
+        return [
+            {
+                title: 'No Authentication',
+                name: 'none',
+            },
+            {
+                title: 'Basic Authentication',
+                name: 'basic',
+            },
+            {
+                title: 'Bearer Token Authentication',
+                name: 'bearer',
+            },
+            {
+                title: 'API Key Authentication',
+                name: 'apikey',
+            },
+        ];
+    },
+    showAuthConnectionField: (field, values) => {
+        if (field === 'authType')
+            return true;
+        if ((values === null || values === void 0 ? void 0 : values.authType) === 'basic') {
+            if (field === 'user')
+                return true;
+            if (field === 'password')
+                return true;
+        }
+        if ((values === null || values === void 0 ? void 0 : values.authType) === 'bearer') {
+            if (field === 'authToken')
+                return true;
+        }
+        if ((values === null || values === void 0 ? void 0 : values.authType) === 'apikey') {
+            if (field === 'apiKeyHeader')
+                return true;
+            if (field === 'apiKeyValue')
+                return true;
+        }
+        return false;
+    },
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "version": "7.1.3-alpha.2",
+  "name": "dbgate-rest",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "homepage": "https://www.dbgate.io/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dbgate/dbgate.git"
+  },
+  "author": "Jan Prochazka",
+  "license": "GPL-3.0",
+  "keywords": [
+    "sql",
+    "dbgate"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "tsc --watch",
+    "prepublishOnly": "yarn build",
+    "test": "jest",
+    "test:ci": "jest --json --outputFile=result.json --testLocationInResults"
+  },
+  "files": [
+    "lib"
+  ],
+  "devDependencies": {
+    "@types/node": "^13.7.0",
+    "dbgate-types": "7.1.3-alpha.2",
+    "jest": "^28.1.3",
+    "ts-jest": "^28.0.7",
+    "typescript": "^4.4.3"
+  },
+  "dependencies": {
+    "dbgate-tools": "7.1.3-alpha.2",
+    "lodash": "^4.17.21",
+    "openapi-types": "^12.1.3",
+    "pinomin": "^1.0.5",
+    "uuid": "^3.4.0",
+    "js-yaml": "^4.1.0"
+  }
+}