dbgate-rest 7.1.3-alpha.2

package/lib/oDataAdapter.js

@@ -0,0 +1,358 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyseODataDefinition = void 0;
+const oDataMetadataParser_1 = require("./oDataMetadataParser");
+function normalizeServiceRoot(contextUrl, fallbackUrl) {
+    const safeFallback = String(fallbackUrl !== null && fallbackUrl !== void 0 ? fallbackUrl : '').trim();
+    if (typeof contextUrl === 'string' && contextUrl.trim()) {
+        try {
+            const resolved = new URL(contextUrl.trim(), safeFallback || undefined);
+            resolved.hash = '';
+            resolved.search = '';
+            resolved.pathname = resolved.pathname.replace(/\/$metadata$/i, '');
+            const url = resolved.toString();
+            return url.endsWith('/') ? url : `${url}/`;
+        }
+        catch (_a) {
+            // ignore, fallback below
+        }
+    }
+    return safeFallback.endsWith('/') ? safeFallback : `${safeFallback}/`;
+}
+function normalizeEndpointPath(valueUrl) {
+    const input = String(valueUrl !== null && valueUrl !== void 0 ? valueUrl : '').trim();
+    if (!input)
+        return null;
+    try {
+        const parsed = new URL(input, 'http://odata.local');
+        const pathWithQuery = `${parsed.pathname}${parsed.search}`;
+        return pathWithQuery.startsWith('/') ? pathWithQuery : `/${pathWithQuery}`;
+    }
+    catch (_a) {
+        return input.startsWith('/') ? input : `/${input}`;
+    }
+}
+function inferMethods(kind) {
+    const normalizedKind = String(kind !== null && kind !== void 0 ? kind : '').toLowerCase();
+    if (normalizedKind === 'actionimport')
+        return ['POST'];
+    if (normalizedKind === 'entityset')
+        return ['GET', 'POST'];
+    return ['GET'];
+}
+function toLowerCamelCase(value) {
+    const text = String(value !== null && value !== void 0 ? value : '').trim();
+    if (!text)
+        return '';
+    return text.charAt(0).toLowerCase() + text.slice(1);
+}
+function normalizeSingularName(value) {
+    const text = String(value !== null && value !== void 0 ? value : '').trim();
+    if (!text)
+        return '';
+    if (/ies$/i.test(text))
+        return `${text.slice(0, -3)}y`;
+    if (/sses$/i.test(text))
+        return text;
+    if (/s$/i.test(text) && text.length > 1)
+        return text.slice(0, -1);
+    return text;
+}
+function normalizePluralName(value) {
+    const text = String(value !== null && value !== void 0 ? value : '').trim();
+    if (!text)
+        return '';
+    if (/y$/i.test(text))
+        return `${text.slice(0, -1)}ies`;
+    if (/s$/i.test(text))
+        return text;
+    return `${text}s`;
+}
+function normalizeEntityTypeName(typeName) {
+    const text = String(typeName !== null && typeName !== void 0 ? typeName : '').trim();
+    if (!text)
+        return '';
+    const collectionMatch = text.match(/^Collection\((.+)\)$/i);
+    const unwrapped = collectionMatch ? collectionMatch[1] : text;
+    const slashStripped = unwrapped.includes('/') ? unwrapped.split('/').pop() || unwrapped : unwrapped;
+    return slashStripped.trim();
+}
+function buildTypeReferenceKeys(typeReference) {
+    const normalizedReference = normalizeEntityTypeName(typeReference);
+    if (!normalizedReference)
+        return [];
+    const keys = new Set();
+    const lower = normalizedReference.toLowerCase();
+    keys.add(lower);
+    const withoutNamespace = normalizedReference.includes('.')
+        ? normalizedReference.split('.').pop() || normalizedReference
+        : normalizedReference;
+    keys.add(withoutNamespace.toLowerCase());
+    return Array.from(keys);
+}
+function buildEntityTypeLookup(entityTypes) {
+    const lookup = new Map();
+    for (const [entityTypeKey, entityType] of Object.entries(entityTypes || {})) {
+        const keys = new Set([
+            ...buildTypeReferenceKeys(entityTypeKey),
+            ...buildTypeReferenceKeys(entityType.fullTypeName),
+            ...buildTypeReferenceKeys(entityType.typeName),
+        ]);
+        for (const key of keys) {
+            if (!lookup.has(key)) {
+                lookup.set(key, entityType);
+            }
+        }
+    }
+    return lookup;
+}
+function resolveEntityType(entityTypeLookup, typeReference) {
+    const keys = buildTypeReferenceKeys(typeReference);
+    for (const key of keys) {
+        const found = entityTypeLookup.get(key);
+        if (found)
+            return found;
+    }
+    return null;
+}
+function resolveLookupPath(entitySetName, serviceResourceMap) {
+    var _a;
+    const serviceResource = serviceResourceMap.get(entitySetName);
+    const resourceUrl = String((_a = serviceResource === null || serviceResource === void 0 ? void 0 : serviceResource.url) !== null && _a !== void 0 ? _a : '').trim();
+    if (!resourceUrl)
+        return `/${entitySetName}`;
+    return resourceUrl.startsWith('/') ? resourceUrl : `/${resourceUrl}`;
+}
+function buildServiceResourceNameLookup(resources) {
+    var _a;
+    const lookup = new Map();
+    for (const resource of resources || []) {
+        const resourceName = String((_a = resource === null || resource === void 0 ? void 0 : resource.name) !== null && _a !== void 0 ? _a : '').trim();
+        if (!resourceName)
+            continue;
+        const lower = resourceName.toLowerCase();
+        if (!lookup.has(lower)) {
+            lookup.set(lower, resourceName);
+        }
+    }
+    return lookup;
+}
+function resolveServiceResourceNameForEntityType(entityType, serviceResourceNameLookup) {
+    var _a;
+    const baseNames = [
+        String((_a = entityType === null || entityType === void 0 ? void 0 : entityType.typeName) !== null && _a !== void 0 ? _a : '').trim(),
+        normalizeSingularName(entityType === null || entityType === void 0 ? void 0 : entityType.typeName),
+        normalizeEntityTypeName(entityType === null || entityType === void 0 ? void 0 : entityType.fullTypeName),
+        normalizeSingularName(normalizeEntityTypeName(entityType === null || entityType === void 0 ? void 0 : entityType.fullTypeName)),
+    ].filter(Boolean);
+    const candidates = new Set();
+    for (const baseName of baseNames) {
+        candidates.add(baseName);
+        candidates.add(normalizeSingularName(baseName));
+        candidates.add(normalizePluralName(baseName));
+    }
+    for (const candidate of candidates) {
+        const matched = serviceResourceNameLookup.get(String(candidate).toLowerCase());
+        if (matched)
+            return matched;
+    }
+    return null;
+}
+function deduceMandatoryNavigationByTarget(metadataDocument, resources) {
+    var _a, _b, _c, _d;
+    if (!metadataDocument)
+        return {};
+    const entityTypeLookup = buildEntityTypeLookup(metadataDocument.entityTypes || {});
+    const serviceResourceMap = new Map();
+    for (const resource of resources) {
+        const resourceName = String((_a = resource === null || resource === void 0 ? void 0 : resource.name) !== null && _a !== void 0 ? _a : '').trim();
+        if (resourceName) {
+            serviceResourceMap.set(resourceName, resource);
+        }
+    }
+    const serviceResourceNameLookup = buildServiceResourceNameLookup(resources);
+    const entitySetsByEntityType = new Map();
+    for (const [entitySetName, entitySet] of Object.entries(metadataDocument.entitySets || {})) {
+        const typeKeys = buildTypeReferenceKeys(entitySet === null || entitySet === void 0 ? void 0 : entitySet.entityType);
+        if (typeKeys.length === 0)
+            continue;
+        for (const typeKey of typeKeys) {
+            const list = entitySetsByEntityType.get(typeKey) || [];
+            if (!list.includes(entitySetName)) {
+                list.push(entitySetName);
+                entitySetsByEntityType.set(typeKey, list);
+            }
+        }
+    }
+    const mandatoryByTarget = {};
+    const parentContexts = [];
+    const parentTypeKeysCovered = new Set();
+    for (const [parentEntitySetName, parentEntitySet] of Object.entries(metadataDocument.entitySets || {})) {
+        const parentType = resolveEntityType(entityTypeLookup, parentEntitySet.entityType);
+        if (!parentType)
+            continue;
+        parentContexts.push({
+            parentEntitySetName,
+            parentType,
+            navigationBindings: parentEntitySet.navigationBindings || {},
+        });
+        for (const typeKey of buildTypeReferenceKeys(parentEntitySet.entityType)) {
+            parentTypeKeysCovered.add(typeKey);
+        }
+    }
+    for (const entityType of Object.values(metadataDocument.entityTypes || {})) {
+        const typeKeys = [
+            ...buildTypeReferenceKeys(entityType.fullTypeName),
+            ...buildTypeReferenceKeys(entityType.typeName),
+        ];
+        const alreadyCovered = typeKeys.some(typeKey => parentTypeKeysCovered.has(typeKey));
+        if (alreadyCovered)
+            continue;
+        if (!Array.isArray(entityType.navigationProperties) || entityType.navigationProperties.length === 0) {
+            continue;
+        }
+        const parentEntitySetName = resolveServiceResourceNameForEntityType(entityType, serviceResourceNameLookup);
+        if (!parentEntitySetName)
+            continue;
+        parentContexts.push({
+            parentEntitySetName,
+            parentType: entityType,
+            navigationBindings: {},
+        });
+        for (const typeKey of typeKeys) {
+            parentTypeKeysCovered.add(typeKey);
+        }
+    }
+    for (const { parentEntitySetName, parentType, navigationBindings } of parentContexts) {
+        const parentParamName = toLowerCamelCase(parentType.typeName) ||
+            toLowerCamelCase(normalizeSingularName(parentEntitySetName)) ||
+            toLowerCamelCase(parentEntitySetName);
+        if (!parentParamName)
+            continue;
+        for (const navProperty of parentType.navigationProperties || []) {
+            if (!navProperty.containsTarget)
+                continue;
+            const targetNames = new Set();
+            const directBoundTarget = navigationBindings === null || navigationBindings === void 0 ? void 0 : navigationBindings[navProperty.name];
+            if (directBoundTarget) {
+                targetNames.add(directBoundTarget);
+            }
+            const navTypeKeys = buildTypeReferenceKeys(navProperty.type);
+            if (navTypeKeys.length > 0) {
+                const typeTargets = navTypeKeys.flatMap(typeKey => entitySetsByEntityType.get(typeKey) || []);
+                for (const targetName of typeTargets) {
+                    targetNames.add(targetName);
+                }
+            }
+            for (const targetEntitySetName of targetNames) {
+                const targetList = mandatoryByTarget[targetEntitySetName] || [];
+                const exists = targetList.some(item => item.name.toLowerCase() === parentParamName.toLowerCase());
+                if (exists)
+                    continue;
+                targetList.push({
+                    name: parentParamName,
+                    lookupEntitySet: parentEntitySetName,
+                    lookupPath: resolveLookupPath(parentEntitySetName, serviceResourceMap),
+                    lookupValueField: (_b = parentType.keyProperties) === null || _b === void 0 ? void 0 : _b[0],
+                    lookupLabelField: ((_c = parentType.stringProperties) === null || _c === void 0 ? void 0 : _c.find(prop => /name/i.test(prop))) || ((_d = parentType.stringProperties) === null || _d === void 0 ? void 0 : _d[0]),
+                });
+                mandatoryByTarget[targetEntitySetName] = targetList;
+            }
+        }
+    }
+    return mandatoryByTarget;
+}
+function buildMandatoryNavigationParameters(resource, mandatoryByTarget) {
+    var _a;
+    const resourceName = String((_a = resource === null || resource === void 0 ? void 0 : resource.name) !== null && _a !== void 0 ? _a : '').trim();
+    if (!resourceName)
+        return [];
+    const mandatoryTargets = mandatoryByTarget[resourceName] || [];
+    const mandatoryParameters = [];
+    const seenNames = new Set();
+    for (const mandatoryTarget of mandatoryTargets) {
+        const normalizedName = mandatoryTarget.name.toLowerCase();
+        if (seenNames.has(normalizedName))
+            continue;
+        const description = mandatoryTarget.lookupEntitySet
+            ? `Required navigation parameter deduced from OData metadata (lookup: ${mandatoryTarget.lookupEntitySet})`
+            : 'Required navigation parameter deduced from OData metadata';
+        mandatoryParameters.push({
+            name: mandatoryTarget.name,
+            in: 'query',
+            dataType: 'string',
+            required: true,
+            description,
+            odataLookupPath: mandatoryTarget.lookupPath,
+            odataLookupEntitySet: mandatoryTarget.lookupEntitySet,
+            odataLookupValueField: mandatoryTarget.lookupValueField,
+            odataLookupLabelField: mandatoryTarget.lookupLabelField,
+        });
+        seenNames.add(normalizedName);
+    }
+    return mandatoryParameters;
+}
+function createODataResourceEndpoints(resource, mandatoryByTarget) {
+    var _a;
+    const path = normalizeEndpointPath(resource.url);
+    if (!path)
+        return [];
+    const summary = resource.name || resource.url || path;
+    const descriptionKind = String((_a = resource.kind) !== null && _a !== void 0 ? _a : '').trim();
+    const methods = inferMethods(resource.kind);
+    const mandatoryNavigationParameters = buildMandatoryNavigationParameters(resource, mandatoryByTarget);
+    return methods.map(method => {
+        const parameters = [...mandatoryNavigationParameters];
+        if (method === 'POST') {
+            parameters.push({
+                name: 'body',
+                in: 'body',
+                dataType: 'object',
+                contentType: 'application/json',
+            });
+        }
+        return {
+            method,
+            path,
+            summary,
+            description: descriptionKind ? `OData ${descriptionKind}` : 'OData resource',
+            parameters,
+        };
+    });
+}
+function analyseODataDefinition(doc, endpointUrl, metadataDocumentXml) {
+    var _a;
+    const resources = Array.isArray(doc === null || doc === void 0 ? void 0 : doc.value) ? doc.value : [];
+    const categoriesByName = new Map();
+    const metadataDocument = metadataDocumentXml ? (0, oDataMetadataParser_1.parseODataMetadataDocument)(metadataDocumentXml) : null;
+    const mandatoryByTarget = deduceMandatoryNavigationByTarget(metadataDocument, resources);
+    for (const resource of resources) {
+        const endpoints = createODataResourceEndpoints(resource, mandatoryByTarget);
+        if (endpoints.length === 0)
+            continue;
+        const categoryName = String((_a = resource.kind) !== null && _a !== void 0 ? _a : 'Resources').trim() || 'Resources';
+        const existingEndpoints = categoriesByName.get(categoryName) || [];
+        existingEndpoints.push(...endpoints);
+        categoriesByName.set(categoryName, existingEndpoints);
+    }
+    const metadataEndpoint = {
+        method: 'GET',
+        path: '/$metadata',
+        summary: '$metadata',
+        description: 'OData service metadata',
+        parameters: [],
+    };
+    const metadataCategory = categoriesByName.get('Metadata') || [];
+    metadataCategory.push(metadataEndpoint);
+    categoriesByName.set('Metadata', metadataCategory);
+    const serviceRoot = normalizeServiceRoot(doc === null || doc === void 0 ? void 0 : doc['@odata.context'], endpointUrl);
+    const servers = serviceRoot ? [{ url: serviceRoot }] : [];
+    return {
+        categories: Array.from(categoriesByName.entries()).map(([name, endpoints]) => ({
+            name,
+            endpoints,
+        })),
+        servers,
+    };
+}
+exports.analyseODataDefinition = analyseODataDefinition;

package/lib/oDataAdapter.test.d.ts

@@ -0,0 +1,2 @@
+declare const analyseODataDefinition: any;
+declare function findEndpoint(apiInfo: any, path: any, method?: string): any;

package/lib/oDataAdapter.test.js

@@ -0,0 +1,61 @@
+const { analyseODataDefinition } = require('./oDataAdapter');
+function findEndpoint(apiInfo, path, method = 'GET') {
+    return apiInfo.categories
+        .flatMap(category => category.endpoints)
+        .find(endpoint => endpoint.path === path && endpoint.method === method);
+}
+test('deduces mandatory company parameter for customers and items from ContainsTarget metadata', () => {
+    const serviceDocument = {
+        '@odata.context': 'https://example/odata/$metadata',
+        value: [
+            { name: 'companies', kind: 'EntitySet', url: 'companies' },
+            { name: 'customers', kind: 'EntitySet', url: 'customers' },
+            { name: 'items', kind: 'EntitySet', url: 'items' },
+        ],
+    };
+    const metadataXml = `<?xml version="1.0" encoding="utf-8"?>
+<edmx:Edmx Version="4.0" xmlns:edmx="http://docs.oasis-open.org/odata/ns/edmx">
+  <edmx:DataServices>
+    <Schema Namespace="Microsoft.NAV" Alias="NAV" xmlns="http://docs.oasis-open.org/odata/ns/edm">
+      <EntityType Name="company">
+        <Key><PropertyRef Name="id"/></Key>
+        <Property Name="id" Type="Edm.Guid"/>
+        <Property Name="displayName" Type="Edm.String"/>
+        <NavigationProperty Name="customers" Type="Collection(NAV.customer)" ContainsTarget="true" />
+        <NavigationProperty Name="items" Type="Collection(NAV.item)" ContainsTarget="true" />
+      </EntityType>
+      <EntityType Name="customer">
+        <Property Name="id" Type="Edm.Guid"/>
+      </EntityType>
+      <EntityType Name="item">
+        <Property Name="id" Type="Edm.Guid"/>
+      </EntityType>
+      <EntityContainer Name="default">
+        <EntitySet Name="companies" EntityType="NAV.company">
+          <NavigationPropertyBinding Path="customers" Target="customers"/>
+          <NavigationPropertyBinding Path="items" Target="items"/>
+        </EntitySet>
+        <EntitySet Name="customers" EntityType="NAV.customer"/>
+        <EntitySet Name="items" EntityType="NAV.item"/>
+      </EntityContainer>
+    </Schema>
+  </edmx:DataServices>
+</edmx:Edmx>`;
+    const apiInfo = analyseODataDefinition(serviceDocument, 'https://example/odata', metadataXml);
+    const customersGet = findEndpoint(apiInfo, '/customers', 'GET');
+    const itemsGet = findEndpoint(apiInfo, '/items', 'GET');
+    expect(customersGet).toBeDefined();
+    expect(itemsGet).toBeDefined();
+    const customersCompany = customersGet.parameters.find(param => param.name === 'company');
+    const itemsCompany = itemsGet.parameters.find(param => param.name === 'company');
+    expect(customersCompany).toBeDefined();
+    expect(customersCompany.required).toBe(true);
+    expect(customersCompany.in).toBe('query');
+    expect(customersCompany.odataLookupEntitySet).toBe('companies');
+    expect(customersCompany.odataLookupPath).toBe('/companies');
+    expect(itemsCompany).toBeDefined();
+    expect(itemsCompany.required).toBe(true);
+    expect(itemsCompany.in).toBe('query');
+    expect(itemsCompany.odataLookupEntitySet).toBe('companies');
+    expect(itemsCompany.odataLookupPath).toBe('/companies');
+});

package/lib/oDataDriver.d.ts

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

package/lib/oDataDriver.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oDataDriver = void 0;
+const restAuthTools_1 = require("./restAuthTools");
+const restDriverBase_1 = require("./restDriverBase");
+function resolveServiceRoot(contextUrl, fallbackUrl) {
+    const safeFallback = String(fallbackUrl !== null && fallbackUrl !== void 0 ? fallbackUrl : '').trim();
+    if (typeof contextUrl === 'string' && contextUrl.trim()) {
+        try {
+            const resolved = new URL(contextUrl.trim(), safeFallback || undefined);
+            resolved.hash = '';
+            resolved.search = '';
+            resolved.pathname = resolved.pathname.replace(/\/$metadata$/i, '');
+            const url = resolved.toString();
+            return url.endsWith('/') ? url : `${url}/`;
+        }
+        catch (_a) {
+            // ignore, fallback below
+        }
+    }
+    return safeFallback.endsWith('/') ? safeFallback : `${safeFallback}/`;
+}
+async function loadODataServiceDocument(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-00000 OData endpoint URL is not configured');
+    }
+    const response = await dbhan.axios.get(dbhan.connection.apiServerUrl1, {
+        headers: (0, restAuthTools_1.buildRestAuthHeaders)(dbhan.connection.restAuth),
+    });
+    const document = response === null || response === void 0 ? void 0 : response.data;
+    if (!document || typeof document !== 'object') {
+        throw new Error('DBGM-00000 OData service document is empty or invalid');
+    }
+    if (!document['@odata.context']) {
+        throw new Error('DBGM-00000 OData service document does not contain @odata.context');
+    }
+    return document;
+}
+function getODataVersion(document) {
+    var _a;
+    const contextUrl = String((_a = document === null || document === void 0 ? void 0 : document['@odata.context']) !== null && _a !== void 0 ? _a : '').trim();
+    const versionMatch = contextUrl.match(/\/v(\d+(?:\.\d+)*)\/$metadata$/i);
+    if (versionMatch === null || versionMatch === void 0 ? void 0 : versionMatch[1])
+        return versionMatch[1];
+    return '';
+}
+// @ts-ignore
+exports.oDataDriver = {
+    ...restDriverBase_1.apiDriverBase,
+    engine: 'odata@rest',
+    title: 'OData - REST',
+    databaseEngineTypes: ['rest', 'odata'],
+    icon: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 128 128"><rect width="128" height="128" fill="#f9a000"/><rect x="12" y="12" width="47" height="12" fill="#ffffff"/><rect x="69" y="12" width="47" height="12" fill="#ffffff"/><rect x="12" y="37" width="47" height="12" fill="#ffffff"/><rect x="69" y="37" width="47" height="12" fill="#ffffff"/><rect x="12" y="62" width="47" height="12" fill="#ffffff"/><rect x="69" y="62" width="47" height="12" fill="#ffffff"/><rect x="69" y="87" width="47" height="12" fill="#ffffff"/><circle cx="35" cy="102" r="20" fill="#e6e6e6"/></svg>',
+    apiServerUrl1Label: 'OData Service URL',
+    showConnectionField: (field, values) => {
+        if (restDriverBase_1.apiDriverBase.showAuthConnectionField(field, values))
+            return true;
+        if (field === 'apiServerUrl1')
+            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 getVersion(dbhan) {
+        const document = await loadODataServiceDocument(dbhan);
+        const resourcesCount = Array.isArray(document === null || document === void 0 ? void 0 : document.value) ? document.value.length : 0;
+        const odataVersion = getODataVersion(document);
+        return {
+            version: odataVersion || 'OData',
+            versionText: `OData${odataVersion ? ` ${odataVersion}` : ''}, ${resourcesCount} resources`,
+        };
+    },
+};

package/lib/oDataMetadataParser.d.ts

@@ -0,0 +1,2 @@
+import type { ODataMetadataDocument } from './oDataAdapter';
+export declare function parseODataMetadataDocument(metadataXml: string): ODataMetadataDocument;

package/lib/oDataMetadataParser.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseODataMetadataDocument = void 0;
+function decodeXmlEntities(value) {
+    return String(value !== null && value !== void 0 ? value : '')
+        .replace(/"/g, '"')
+        .replace(/'/g, "'")
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&amp;/g, '&');
+}
+function parseXmlAttributes(attributesText) {
+    var _a, _b;
+    const attributes = {};
+    const regex = /([A-Za-z_][A-Za-z0-9_.:-]*)\s*=\s*("([^"]*)"|'([^']*)')/g;
+    let match = regex.exec(attributesText || '');
+    while (match) {
+        const rawName = match[1];
+        const localName = rawName.includes(':') ? rawName.split(':').pop() || rawName : rawName;
+        const rawValue = (_b = (_a = match[3]) !== null && _a !== void 0 ? _a : match[4]) !== null && _b !== void 0 ? _b : '';
+        const decoded = decodeXmlEntities(rawValue);
+        attributes[rawName] = decoded;
+        attributes[localName] = decoded;
+        match = regex.exec(attributesText || '');
+    }
+    return attributes;
+}
+function extractXmlElements(xml, elementName) {
+    const elements = [];
+    const fullTagRegex = new RegExp(`<(?:[A-Za-z_][A-Za-z0-9_.-]*:)?${elementName}\\b([^>]*)>([\\s\\S]*?)<\\/(?:[A-Za-z_][A-Za-z0-9_.-]*:)?${elementName}>`, 'gi');
+    const selfClosingRegex = new RegExp(`<(?:[A-Za-z_][A-Za-z0-9_.-]*:)?${elementName}\\b([^>]*)\\/>`, 'gi');
+    let fullMatch = fullTagRegex.exec(xml || '');
+    while (fullMatch) {
+        elements.push({
+            attributes: parseXmlAttributes(fullMatch[1] || ''),
+            innerXml: fullMatch[2] || '',
+        });
+        fullMatch = fullTagRegex.exec(xml || '');
+    }
+    let selfClosingMatch = selfClosingRegex.exec(xml || '');
+    while (selfClosingMatch) {
+        elements.push({
+            attributes: parseXmlAttributes(selfClosingMatch[1] || ''),
+            innerXml: '',
+        });
+        selfClosingMatch = selfClosingRegex.exec(xml || '');
+    }
+    return elements;
+}
+function toBoolAttribute(value) {
+    return String(value !== null && value !== void 0 ? value : '').trim().toLowerCase() === 'true';
+}
+function normalizeEntitySetName(value) {
+    const input = String(value !== null && value !== void 0 ? value : '').trim();
+    if (!input)
+        return '';
+    const noContainer = input.includes('/') ? input.split('/').pop() || '' : input;
+    return noContainer.includes('.') ? noContainer.split('.').pop() || noContainer : noContainer;
+}
+function parseODataMetadataDocument(metadataXml) {
+    const schemas = extractXmlElements(metadataXml || '', 'Schema');
+    const entityTypes = {};
+    const entitySets = {};
+    for (const schema of schemas) {
+        const namespace = String(schema.attributes.Namespace || '').trim();
+        for (const entityTypeNode of extractXmlElements(schema.innerXml, 'EntityType')) {
+            const typeName = String(entityTypeNode.attributes.Name || '').trim();
+            if (!typeName)
+                continue;
+            const fullTypeName = namespace ? `${namespace}.${typeName}` : typeName;
+            const keyProperties = [];
+            const stringProperties = [];
+            const navigationProperties = [];
+            for (const keyNode of extractXmlElements(entityTypeNode.innerXml, 'Key')) {
+                for (const propRef of extractXmlElements(keyNode.innerXml, 'PropertyRef')) {
+                    const keyName = String(propRef.attributes.Name || '').trim();
+                    if (keyName && !keyProperties.includes(keyName)) {
+                        keyProperties.push(keyName);
+                    }
+                }
+            }
+            for (const propertyNode of extractXmlElements(entityTypeNode.innerXml, 'Property')) {
+                const propName = String(propertyNode.attributes.Name || '').trim();
+                const propType = String(propertyNode.attributes.Type || '').trim();
+                if (propName && /^Edm\.String$/i.test(propType)) {
+                    stringProperties.push(propName);
+                }
+            }
+            for (const navNode of extractXmlElements(entityTypeNode.innerXml, 'NavigationProperty')) {
+                const navName = String(navNode.attributes.Name || '').trim();
+                if (!navName)
+                    continue;
+                navigationProperties.push({
+                    name: navName,
+                    type: String(navNode.attributes.Type || '').trim(),
+                    containsTarget: toBoolAttribute(navNode.attributes.ContainsTarget),
+                    nullable: navNode.attributes.Nullable === undefined ? true : toBoolAttribute(navNode.attributes.Nullable),
+                });
+            }
+            entityTypes[fullTypeName] = {
+                typeName,
+                fullTypeName,
+                keyProperties,
+                stringProperties,
+                navigationProperties,
+            };
+        }
+        for (const entitySetNode of extractXmlElements(schema.innerXml, 'EntitySet')) {
+            const setName = String(entitySetNode.attributes.Name || '').trim();
+            const entityType = String(entitySetNode.attributes.EntityType || '').trim();
+            if (!setName || !entityType)
+                continue;
+            const navigationBindings = {};
+            for (const bindingNode of extractXmlElements(entitySetNode.innerXml, 'NavigationPropertyBinding')) {
+                const path = String(bindingNode.attributes.Path || '').trim();
+                const target = normalizeEntitySetName(bindingNode.attributes.Target);
+                if (!path || !target)
+                    continue;
+                navigationBindings[path] = target;
+                const pathLastSegment = path.split('/').pop();
+                if (pathLastSegment && !navigationBindings[pathLastSegment]) {
+                    navigationBindings[pathLastSegment] = target;
+                }
+            }
+            entitySets[setName] = {
+                name: setName,
+                entityType,
+                navigationBindings,
+            };
+        }
+    }
+    return {
+        entityTypes,
+        entitySets,
+    };
+}
+exports.parseODataMetadataDocument = parseODataMetadataDocument;

package/lib/openApiAdapter.d.ts

@@ -0,0 +1,7 @@
+import type { OpenAPIV3_1 } from 'openapi-types';
+import { RestApiDefinition } from './restApiDef';
+/**
+ * Converts an OpenAPI v3.1 document into a simplified REST API definition
+ * Organizes endpoints by tags into categories
+ */
+export declare function analyseOpenApiDefinition(doc: OpenAPIV3_1.Document): RestApiDefinition;