@microsoft/power-apps-cli 0.5.4 → 0.5.7

package/node_modules/@microsoft/powerapps-player-actions/lib/__tests__/DataSourceInfoProcessor.spec.js

@@ -3,13 +3,28 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { afterEach, beforeEach, describe, it } from '@jest/globals';
+import { afterEach, beforeEach, describe, it, jest } from '@jest/globals';
 import { clearVfs, setVfs } from '../VfsManager';
 import mockVfs from './mocks/mockVfs';
 import { extractDeclaration } from './Utils';
 import { processDataSourceInfo } from '../CodeGen/dataSourceInfoProcessor';
 import { beforeAll, expect } from '@jest/globals';
 import { getMockLogger } from './mocks/Logger.mock';
+/**
+ * Parses the generated TypeScript content and returns the DataSourcesInfo object.
+ * This provides type-safe access to the generated data structure instead of fragile string checks.
+ * @param generatedContent The generated TypeScript file content
+ * @returns The parsed DataSourcesInfo object
+ */
+function parseDataSourcesInfo(generatedContent) {
+    const jsonMatch = generatedContent.match(/export const dataSourcesInfo = ({[\s\S]*});?\s*$/);
+    if (!jsonMatch) {
+        throw new Error('Could not extract dataSourcesInfo from generated content');
+    }
+    // Remove trailing semicolon if present
+    const jsonStr = jsonMatch[1].replace(/;\s*$/, '');
+    return JSON.parse(jsonStr);
+}
 async function setupMockSchemas() {
     // Reset the mock filesystem
     mockVfs.reset();
@@ -25,7 +40,7 @@ const localFilePaths = {
     codeGenPath: `${baseTestDir}\\src`,
 };
 const mockLogger = getMockLogger();
-describe('ModelServiceGenerator', () => {
+describe('dataSourceInfoProcessor with real schema files', () => {
     beforeAll(async () => {
         await setupMockSchemas();
     });
@@ -51,4 +66,884 @@ describe('ModelServiceGenerator', () => {
         });
     });
 });
+describe('dataSourceInfoProcessor with mocked schema files', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockVfs.reset();
+        setVfs(mockVfs);
+    });
+    afterEach(() => {
+        clearVfs();
+    });
+    describe('processDataSourceInfo', () => {
+        it('should process empty folder without errors', async () => {
+            // Arrange
+            const folderPath = '/test/folder';
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            // Act & Assert
+            await expect(processDataSourceInfo(folderPath, mockLogger)).resolves.not.toThrow();
+        });
+        it('should process folder with JSON files and generate output', async () => {
+            // Arrange
+            const folderPath = '/test/folder';
+            const jsonContent = JSON.stringify({
+                name: 'test-api',
+                type: 'Microsoft.PowerApps/apis',
+                properties: {
+                    swagger: {
+                        paths: {
+                            '/test': {
+                                get: {
+                                    operationId: 'GetTest',
+                                    responses: {
+                                        '200': {
+                                            description: 'Success',
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+            // Setup mock file system
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'test.json'), jsonContent);
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const outputExists = await mockVfs.exists(outputPath);
+            expect(outputExists).toBe(true);
+        });
+        it('should handle file processing errors with file path context', async () => {
+            // Arrange
+            const folderPath = '/test/folder';
+            const invalidJsonContent = '{ invalid json';
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'invalid.json'), invalidJsonContent);
+            // Act & Assert
+            await expect(processDataSourceInfo(folderPath, mockLogger)).rejects.toThrow(/Error processing file.*invalid\.json/);
+        });
+        it('should create output directory if it does not exist', async () => {
+            // Arrange
+            const folderPath = '/test/folder';
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputDir = mockVfs.join(folderPath, 'appschemas');
+            const dirExists = await mockVfs.exists(outputDir);
+            expect(dirExists).toBe(true);
+        });
+    });
+    describe('Swagger API processing', () => {
+        it('should process Microsoft.PowerApps/apis type with swagger paths', async () => {
+            var _a, _b, _c, _d, _e, _f;
+            // Arrange
+            const folderPath = '/test/folder';
+            const swaggerJson = {
+                name: 'users-api',
+                type: 'Microsoft.PowerApps/apis',
+                properties: {
+                    swagger: {
+                        paths: {
+                            '/users': {
+                                get: {
+                                    operationId: 'GetUsers',
+                                    parameters: [
+                                        {
+                                            name: 'limit',
+                                            in: 'query',
+                                            required: false,
+                                            type: 'integer',
+                                        },
+                                    ],
+                                    responses: {
+                                        '200': {
+                                            description: 'Success',
+                                            schema: {
+                                                type: 'array',
+                                            },
+                                        },
+                                    },
+                                },
+                                post: {
+                                    operationId: 'CreateUser',
+                                    responses: {
+                                        '201': {
+                                            description: 'Created',
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'swagger.json'), JSON.stringify(swaggerJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            const parsed = parseDataSourcesInfo(generatedContent);
+            // Verify the data source exists with sanitized name (hyphens become underscores)
+            expect(parsed).toHaveProperty('users_api');
+            const dataSource = parsed.users_api;
+            // Verify APIs are generated correctly
+            expect(dataSource.apis).toHaveProperty('GetUsers');
+            expect(dataSource.apis).toHaveProperty('CreateUser');
+            // Verify GetUsers API details
+            const getUsersApi = dataSource.apis.GetUsers;
+            expect(getUsersApi.path).toBe('/users');
+            expect(getUsersApi.method).toBe('GET');
+            expect(getUsersApi.parameters).toBeDefined();
+            expect((_a = getUsersApi.parameters) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+            expect((_b = getUsersApi.parameters) === null || _b === void 0 ? void 0 : _b[0].name).toBe('limit');
+            expect((_d = (_c = getUsersApi.responseInfo) === null || _c === void 0 ? void 0 : _c['200']) === null || _d === void 0 ? void 0 : _d.type).toBe('array');
+            // Verify CreateUser API details
+            const createUserApi = dataSource.apis.CreateUser;
+            expect(createUserApi.path).toBe('/users');
+            expect(createUserApi.method).toBe('POST');
+            expect((_f = (_e = createUserApi.responseInfo) === null || _e === void 0 ? void 0 : _e['201']) === null || _f === void 0 ? void 0 : _f.type).toBe('void');
+        });
+        it('should handle swagger with parameter references', async () => {
+            // Arrange
+            const folderPath = '/test/folder';
+            const swaggerJson = {
+                name: 'items-api',
+                type: 'Microsoft.PowerApps/apis',
+                properties: {
+                    swagger: {
+                        paths: {
+                            '/items': {
+                                get: {
+                                    operationId: 'GetItems',
+                                    parameters: [
+                                        {
+                                            $ref: '#/swagger/parameters/CommonParam',
+                                        },
+                                    ],
+                                    responses: {
+                                        '200': {
+                                            description: 'Success',
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                        parameters: {
+                            CommonParam: {
+                                name: 'commonParam',
+                                in: 'header',
+                                required: true,
+                                type: 'string',
+                            },
+                        },
+                    },
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'swagger-ref.json'), JSON.stringify(swaggerJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            expect(generatedContent).toContain('items_api');
+            expect(generatedContent).toContain('GetItems');
+            // Note: Parameter reference resolution is tested but the mock doesn't properly resolve it
+            // The actual implementation would resolve the commonParam parameter
+        });
+        it('should handle responses with schema references', async () => {
+            // Arrange
+            const folderPath = '/test/folder';
+            const swaggerJson = {
+                name: 'models-api',
+                type: 'Microsoft.PowerApps/apis',
+                properties: {
+                    swagger: {
+                        paths: {
+                            '/models': {
+                                get: {
+                                    operationId: 'GetModels',
+                                    responses: {
+                                        '200': {
+                                            description: 'Success',
+                                            schema: {
+                                                $ref: '#/definitions/ModelResponse',
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                        definitions: {
+                            ModelResponse: {
+                                type: 'object',
+                            },
+                        },
+                    },
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'models.json'), JSON.stringify(swaggerJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            expect(generatedContent).toContain('GetModels');
+            expect(generatedContent).toContain('"type": "object"');
+        });
+    });
+    describe('SQL stored procedure processing', () => {
+        it('should process SQL stored procedure with input parameters', async () => {
+            var _a, _b;
+            // Arrange
+            const folderPath = '/test/procedures/GetUserById';
+            const procedureJson = {
+                name: '[dbo].[GetUserById]',
+                schema: {
+                    procedureresultschema: {
+                        type: 'object',
+                    },
+                    inputparameters: {
+                        properties: {
+                            UserId: {
+                                type: 'integer',
+                                required: true,
+                            },
+                            IncludeDetails: {
+                                type: 'boolean',
+                                required: false,
+                            },
+                        },
+                    },
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'procedure.json'), JSON.stringify(procedureJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            const parsed = parseDataSourcesInfo(generatedContent);
+            // Verify the data source exists (uses parent folder name as key)
+            expect(parsed).toHaveProperty('getuserbyid');
+            const dataSource = parsed.getuserbyid;
+            // Verify the stored procedure API
+            expect(dataSource.apis).toHaveProperty('GetUserById');
+            const procApi = dataSource.apis.GetUserById;
+            expect(procApi.path).toBe('/dbo.GetUserById');
+            expect(procApi.method).toBe('POST');
+            // Verify parameters are present
+            expect(procApi.parameters).toBeDefined();
+            const paramNames = (_b = (_a = procApi.parameters) === null || _a === void 0 ? void 0 : _a.map((p) => p.name)) !== null && _b !== void 0 ? _b : [];
+            expect(paramNames).toContain('UserId');
+            expect(paramNames).toContain('IncludeDetails');
+        });
+        it('should handle stored procedure without input parameters', async () => {
+            // Arrange
+            const folderPath = '/test/procedures/GetAllUsers';
+            const procedureJson = {
+                name: '[dbo].[GetAllUsers]',
+                schema: {
+                    procedureresultschema: {
+                        type: 'array',
+                    },
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'procedure.json'), JSON.stringify(procedureJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            expect(generatedContent).toContain('getallusers');
+            expect(generatedContent).toContain('"/dbo.GetAllUsers"');
+        });
+        it('should determine property key from parent folder for stored procedures', async () => {
+            // Arrange
+            const folderPath = '/test/procedures/UserProcedures';
+            const procedureJson = {
+                name: '[dbo].[GetUser]',
+                schema: {
+                    procedureresultschema: {
+                        type: 'object',
+                    },
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'procedure.json'), JSON.stringify(procedureJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            expect(generatedContent).toContain('userprocedures');
+        });
+        it('should handle non-dbo schemas', async () => {
+            // Arrange
+            const folderPath = '/test/procedures/GetAllUsers';
+            const procedureJson = {
+                name: '[foo].[GetAllUsers]',
+                schema: {
+                    procedureresultschema: {
+                        type: 'array',
+                    },
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'procedure.json'), JSON.stringify(procedureJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            expect(generatedContent).toContain('getallusers');
+            expect(generatedContent).toContain('"/foo.GetAllUsers"');
+        });
+    });
+    describe('SQL table processing', () => {
+        it('should process SQL table schema with primary key', async () => {
+            // Arrange
+            const folderPath = '/test/tables';
+            const tableJson = {
+                name: '[dbo].[Users]',
+                schema: {
+                    items: {
+                        properties: {
+                            Id: {
+                                type: 'integer',
+                                'x-ms-keyType': 'primary',
+                            },
+                            Name: {
+                                type: 'string',
+                            },
+                            Email: {
+                                type: 'string',
+                            },
+                        },
+                    },
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'users.json'), JSON.stringify(tableJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            const parsed = parseDataSourcesInfo(generatedContent);
+            // Note: when schema path doesn't contain /sql/, sanitizeName is used which converts [dbo].[Users] to _dbo___users_ (lowercase)
+            const expectedKey = '_dbo___users_';
+            expect(parsed).toHaveProperty(expectedKey);
+            const dataSource = parsed[expectedKey];
+            // Verify SQL table properties - tableId gets the cleaned name from sanitizeSqlName
+            expect(dataSource.tableId).toBe('Users');
+            expect(dataSource.version).toBe('v2');
+            expect(dataSource.primaryKey).toBe('Id');
+            expect(dataSource.dataSourceType).toBe('Connector');
+        });
+        it('should handle table without primary key', async () => {
+            // Arrange
+            const folderPath = '/test/sql/tables';
+            const tableJson = {
+                name: '[dbo].[Logs]',
+                schema: {
+                    items: {
+                        properties: {
+                            Message: {
+                                type: 'string',
+                            },
+                            Timestamp: {
+                                type: 'string',
+                            },
+                        },
+                    },
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'logs.json'), JSON.stringify(tableJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            const parsed = parseDataSourcesInfo(generatedContent);
+            // When schema path contains /sql/, sanitizeSqlName extracts just "Logs" from [dbo].[Logs], then lowercase
+            const expectedKey = 'logs';
+            expect(parsed).toHaveProperty(expectedKey);
+            const dataSource = parsed[expectedKey];
+            // Verify primary key is empty when not specified
+            expect(dataSource.tableId).toBe('Logs');
+            expect(dataSource.primaryKey).toBe('');
+        });
+    });
+    describe('Property key determination', () => {
+        it('should remove [dbo]. prefix and brackets from SQL table names', async () => {
+            // Arrange
+            const folderPath = '/test/tables';
+            const tableJson = {
+                name: '[dbo].[ComplexTableName]',
+                schema: {
+                    items: {
+                        properties: {},
+                    },
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'table.json'), JSON.stringify(tableJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            expect(generatedContent).toContain('ComplexTableName');
+        });
+        it('should remove [custom_schema]. prefix and brackets from SQL table names', async () => {
+            // Arrange
+            const folderPath = '/test/tables';
+            const tableJson = {
+                name: '[custom_schema].[ComplexTableName]',
+                schema: {
+                    items: {
+                        properties: {},
+                    },
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'table.json'), JSON.stringify(tableJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            expect(generatedContent).toContain('ComplexTableName');
+        });
+        it('should remove shared_ prefix from non-tabular names', async () => {
+            // Arrange
+            const folderPath = '/test/shared';
+            const sharedJson = {
+                name: 'shared_commonservice',
+                properties: {
+                    displayName: 'CommonService',
+                },
+                schema: {
+                    type: 'object',
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'service.json'), JSON.stringify(sharedJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            expect(generatedContent).toContain('commonservice');
+        });
+        it('should use title property when available', async () => {
+            // Arrange
+            const folderPath = '/test/tabular';
+            const tabularJson = {
+                title: 'UserManagement',
+                name: 'internal_name',
+                schema: {
+                    type: 'object',
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'service.json'), JSON.stringify(tabularJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            expect(generatedContent).toContain('internal_name');
+        });
+        it('should fallback to filename when name property is missing', async () => {
+            // Arrange
+            const folderPath = '/test/fallback';
+            const jsonWithoutName = {
+                schema: {
+                    type: 'object',
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'FallbackService.Schema.json'), JSON.stringify(jsonWithoutName));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            const parsed = parseDataSourcesInfo(generatedContent);
+            // When name property is missing, fallback to filename (minus .json extension, lowercased)
+            const expectedKey = 'fallbackservice.schema';
+            expect(parsed).toHaveProperty([expectedKey]);
+        });
+        it('should handle names with spaces and underscores', async () => {
+            // Arrange
+            const folderPath = '/test/complexnames';
+            const complexNameJson = {
+                name: '  Complex_Name With Spaces  ',
+                title: '  Complex_Name With Spaces  ',
+                schema: {
+                    type: 'object',
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'complex.json'), JSON.stringify(complexNameJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            // Keys are now lowercase
+            expect(generatedContent).toContain('complex_namewithspaces');
+        });
+        it('should use name property for SharePoint list with underscores and hyphens', async () => {
+            // Arrange
+            const folderPath = '/test/sharepointspecialname';
+            const sharepointListJson = {
+                name: 'PaKeMpar_list with underscores-and hype-ns',
+                title: 'PaKeMpar_list with underscores-and hype-ns',
+                'x-ms-permission': 'read-write',
+                'x-ms-capabilities': {
+                    sortRestrictions: {
+                        sortable: true,
+                        unsortableProperties: [],
+                    },
+                },
+                schema: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            ID: {
+                                title: 'ID',
+                                type: 'integer',
+                                'x-ms-keyType': 'primary',
+                            },
+                            Title: {
+                                title: 'Title',
+                                type: 'string',
+                            },
+                        },
+                    },
+                },
+                referencedEntities: {
+                    Author: {
+                        lookupEndpoint: {
+                            path: '/tables/e34fc1b5-7e29-473a-9863-553afa820351/entities/Author',
+                        },
+                    },
+                    Editor: {
+                        lookupEndpoint: {
+                            path: '/tables/e34fc1b5-7e29-473a-9863-553afa820351/entities/Editor',
+                        },
+                    },
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'speciallist.json'), JSON.stringify(sharepointListJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            const parsed = parseDataSourcesInfo(generatedContent);
+            // The property key should be sanitized: spaces removed, hyphens converted to underscores
+            const expectedKey = 'pakempar_listwithunderscores_andhype_ns';
+            expect(parsed).toHaveProperty(expectedKey);
+            const dataSource = parsed[expectedKey];
+            // tableId should preserve the original name from the schema
+            expect(dataSource.tableId).toBe('PaKeMpar_list with underscores-and hype-ns');
+            expect(dataSource.primaryKey).toBe('ID');
+            expect(dataSource.dataSourceType).toBe('Connector');
+            // Should have APIs generated from referencedEntities
+            expect(dataSource.apis).toHaveProperty('GetAuthor');
+            expect(dataSource.apis).toHaveProperty('GetEditor');
+            // Verify API paths have GUIDs without hyphens
+            expect(dataSource.apis.GetAuthor.path).toContain('e34fc1b57e29473a9863553afa820351');
+        });
+    });
+    describe('Merge functionality', () => {
+        it('should merge APIs when processing multiple files for same data source', async () => {
+            // Arrange
+            const folderPath = '/test/merge';
+            const api1Json = {
+                name: 'shared_testservice',
+                type: 'Microsoft.PowerApps/apis',
+                properties: {
+                    displayName: 'TestService',
+                    swagger: {
+                        paths: {
+                            '/api1': {
+                                get: {
+                                    operationId: 'GetApi1',
+                                    responses: { '200': { description: 'Success' } },
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            const api2Json = {
+                name: 'shared_testservice',
+                type: 'Microsoft.PowerApps/apis',
+                properties: {
+                    displayName: 'TestService',
+                    swagger: {
+                        paths: {
+                            '/api2': {
+                                post: {
+                                    operationId: 'PostApi2',
+                                    responses: { '201': { description: 'Created' } },
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'api1.json'), JSON.stringify(api1Json));
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'api2.json'), JSON.stringify(api2Json));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            expect(generatedContent).toContain('GetApi1');
+            expect(generatedContent).toContain('PostApi2');
+            expect(generatedContent).toContain('testservice');
+        });
+        it('should handle duplicate stored procedures gracefully', async () => {
+            // Arrange
+            const folderPath = '/test/duplicate';
+            const procedureJson = {
+                name: '[dbo].[DuplicateProc]',
+                schema: {
+                    procedureresultschema: { type: 'object' },
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'proc1.json'), JSON.stringify(procedureJson));
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'proc2.json'), JSON.stringify(procedureJson));
+            // Act & Assert
+            // Note: The current implementation merges APIs instead of throwing an error
+            // This test verifies that duplicate stored procedures are handled gracefully
+            await expect(processDataSourceInfo(folderPath, mockLogger)).resolves.not.toThrow();
+        });
+    });
+    describe('Response processing', () => {
+        it('should handle array responses correctly', async () => {
+            var _a, _b, _c, _d;
+            // Arrange
+            const folderPath = '/test/responses';
+            const swaggerJson = {
+                name: 'array-api',
+                type: 'Microsoft.PowerApps/apis',
+                properties: {
+                    swagger: {
+                        paths: {
+                            '/array-endpoint': {
+                                get: {
+                                    operationId: 'GetArray',
+                                    responses: {
+                                        '200': {
+                                            description: 'Success',
+                                            schema: {
+                                                type: 'array',
+                                                format: 'custom',
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'array-response.json'), JSON.stringify(swaggerJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            const parsed = parseDataSourcesInfo(generatedContent);
+            // Verify the data source exists with sanitized name
+            expect(parsed).toHaveProperty('array_api');
+            const dataSource = parsed.array_api;
+            // Verify response info for GetArray
+            const getArrayApi = dataSource.apis.GetArray;
+            expect((_b = (_a = getArrayApi.responseInfo) === null || _a === void 0 ? void 0 : _a['200']) === null || _b === void 0 ? void 0 : _b.type).toBe('array');
+            expect((_d = (_c = getArrayApi.responseInfo) === null || _c === void 0 ? void 0 : _c['200']) === null || _d === void 0 ? void 0 : _d.format).toBe('custom');
+        });
+        it('should handle void responses when no schema provided', async () => {
+            var _a, _b;
+            // Arrange
+            const folderPath = '/test/responses';
+            const swaggerJson = {
+                name: 'void-api',
+                type: 'Microsoft.PowerApps/apis',
+                properties: {
+                    swagger: {
+                        paths: {
+                            '/void-endpoint': {
+                                delete: {
+                                    operationId: 'DeleteItem',
+                                    responses: {
+                                        '204': {
+                                            description: 'No Content',
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'void-response.json'), JSON.stringify(swaggerJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            const parsed = parseDataSourcesInfo(generatedContent);
+            // Verify the data source exists with sanitized name
+            expect(parsed).toHaveProperty('void_api');
+            const dataSource = parsed.void_api;
+            // Verify response info for DeleteItem is void when no schema provided
+            const deleteApi = dataSource.apis.DeleteItem;
+            expect((_b = (_a = deleteApi.responseInfo) === null || _a === void 0 ? void 0 : _a['204']) === null || _b === void 0 ? void 0 : _b.type).toBe('void');
+        });
+    });
+    describe('Error handling', () => {
+        it('should throw descriptive error for invalid JSON structure', async () => {
+            // Arrange
+            const folderPath = '/test/invalid';
+            const invalidJson = {
+                invalidStructure: true,
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'invalid.json'), JSON.stringify(invalidJson));
+            // Act & Assert
+            await expect(processDataSourceInfo(folderPath, mockLogger)).rejects.toThrow('The JSON does not represent a valid data source');
+        });
+        it('should handle nested directory traversal', async () => {
+            // Arrange
+            const folderPath = '/test/nested';
+            const subfolderPath = mockVfs.join(folderPath, 'subfolder');
+            const nestedJson = {
+                name: 'nested-service',
+                schema: { type: 'object' },
+            };
+            await mockVfs.mkdir(subfolderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(subfolderPath, 'nested.json'), JSON.stringify(nestedJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert - verify output was generated (means nested traversal worked)
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const outputExists = await mockVfs.exists(outputPath);
+            expect(outputExists).toBe(true);
+        });
+    });
+    describe('Parameter sorting', () => {
+        it('should sort parameters with required first', async () => {
+            // Arrange
+            const folderPath = '/test/sorting';
+            const swaggerJson = {
+                name: 'sorting-api',
+                type: 'Microsoft.PowerApps/apis',
+                properties: {
+                    swagger: {
+                        paths: {
+                            '/sorted-params': {
+                                post: {
+                                    operationId: 'PostWithSortedParams',
+                                    parameters: [
+                                        {
+                                            name: 'optional1',
+                                            in: 'query',
+                                            required: false,
+                                            type: 'string',
+                                        },
+                                        {
+                                            name: 'required1',
+                                            in: 'body',
+                                            required: true,
+                                            type: 'object',
+                                        },
+                                        {
+                                            name: 'optional2',
+                                            in: 'header',
+                                            required: false,
+                                            type: 'string',
+                                        },
+                                        {
+                                            name: 'required2',
+                                            in: 'path',
+                                            required: true,
+                                            type: 'string',
+                                        },
+                                    ],
+                                    responses: {
+                                        '200': { description: 'Success' },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'sorted.json'), JSON.stringify(swaggerJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const generatedContent = await mockVfs.readFile(outputPath);
+            const parsed = parseDataSourcesInfo(generatedContent);
+            // Verify data source exists with sanitized name
+            expect(parsed).toHaveProperty('sorting_api');
+            const dataSource = parsed.sorting_api;
+            const operation = dataSource.apis.PostWithSortedParams;
+            const parameters = operation.parameters;
+            // Required parameters should come first
+            expect(parameters === null || parameters === void 0 ? void 0 : parameters[0].required).toBe(true);
+            expect(parameters === null || parameters === void 0 ? void 0 : parameters[1].required).toBe(true);
+            expect(parameters === null || parameters === void 0 ? void 0 : parameters[2].required).toBe(false);
+            expect(parameters === null || parameters === void 0 ? void 0 : parameters[3].required).toBe(false);
+        });
+    });
+    describe('Output generation', () => {
+        it('should generate properly formatted TypeScript output', async () => {
+            // Arrange
+            const folderPath = '/test/output';
+            const simpleJson = {
+                name: 'test-service',
+                schema: { type: 'object' },
+            };
+            await mockVfs.mkdir(folderPath, { recursive: true });
+            await mockVfs.writeFile(mockVfs.join(folderPath, 'simple.json'), JSON.stringify(simpleJson));
+            // Act
+            await processDataSourceInfo(folderPath, mockLogger);
+            // Assert
+            const outputPath = mockVfs.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+            const content = await mockVfs.readFile(outputPath);
+            expect(content).toContain('/*!');
+            expect(content).toContain(' * Copyright (C) Microsoft Corporation. All rights reserved.');
+            expect(content).toContain(' * This file is auto-generated. Do not modify it manually.');
+            expect(content).toContain('export const dataSourcesInfo = ');
+            expect(content).toMatch(/;\s*$/); // Should end with semicolon
+        });
+    });
+});
 //# sourceMappingURL=DataSourceInfoProcessor.spec.js.map