@microsoft/power-apps-cli 0.5.4 → 0.5.7

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

@@ -74,6 +74,21 @@ var Utils_1 = require("./Utils");
 var dataSourceInfoProcessor_1 = require("../CodeGen/dataSourceInfoProcessor");
 var globals_2 = require("@jest/globals");
 var Logger_mock_1 = require("./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) {
+    var 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
+    var jsonStr = jsonMatch[1].replace(/;\s*$/, '');
+    return JSON.parse(jsonStr);
+}
 function setupMockSchemas() {
     return __awaiter(this, void 0, void 0, function () {
         var basePath, sharepointSchema;
@@ -101,7 +116,7 @@ var localFilePaths = {
     codeGenPath: "".concat(baseTestDir, "\\src"),
 };
 var mockLogger = (0, Logger_mock_1.getMockLogger)();
-(0, globals_1.describe)('ModelServiceGenerator', function () {
+(0, globals_1.describe)('dataSourceInfoProcessor with real schema files', function () {
     (0, globals_2.beforeAll)(function () { return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
@@ -153,4 +168,1265 @@ var mockLogger = (0, Logger_mock_1.getMockLogger)();
         }); });
     });
 });
+(0, globals_1.describe)('dataSourceInfoProcessor with mocked schema files', function () {
+    (0, globals_1.beforeEach)(function () {
+        globals_1.jest.clearAllMocks();
+        mockVfs_1.default.reset();
+        (0, VfsManager_1.setVfs)(mockVfs_1.default);
+    });
+    (0, globals_1.afterEach)(function () {
+        (0, VfsManager_1.clearVfs)();
+    });
+    (0, globals_1.describe)('processDataSourceInfo', function () {
+        (0, globals_1.it)('should process empty folder without errors', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/folder';
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        // Act & Assert
+                        return [4 /*yield*/, (0, globals_2.expect)((0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)).resolves.not.toThrow()];
+                    case 2:
+                        // Act & Assert
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, globals_1.it)('should process folder with JSON files and generate output', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, jsonContent, outputPath, outputExists;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/folder';
+                        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
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        // Setup mock file system
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'test.json'), jsonContent)];
+                    case 2:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _a.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.exists(outputPath)];
+                    case 4:
+                        outputExists = _a.sent();
+                        (0, globals_2.expect)(outputExists).toBe(true);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, globals_1.it)('should handle file processing errors with file path context', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, invalidJsonContent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/folder';
+                        invalidJsonContent = '{ invalid json';
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'invalid.json'), invalidJsonContent)];
+                    case 2:
+                        _a.sent();
+                        // Act & Assert
+                        return [4 /*yield*/, (0, globals_2.expect)((0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)).rejects.toThrow(/Error processing file.*invalid\.json/)];
+                    case 3:
+                        // Act & Assert
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, globals_1.it)('should create output directory if it does not exist', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, outputDir, dirExists;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/folder';
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 2:
+                        // Act
+                        _a.sent();
+                        outputDir = mockVfs_1.default.join(folderPath, 'appschemas');
+                        return [4 /*yield*/, mockVfs_1.default.exists(outputDir)];
+                    case 3:
+                        dirExists = _a.sent();
+                        (0, globals_2.expect)(dirExists).toBe(true);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    (0, globals_1.describe)('Swagger API processing', function () {
+        (0, globals_1.it)('should process Microsoft.PowerApps/apis type with swagger paths', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, swaggerJson, outputPath, generatedContent, parsed, dataSource, getUsersApi, createUserApi;
+            var _a, _b, _c, _d, _e, _f;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        folderPath = '/test/folder';
+                        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',
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _g.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'swagger.json'), JSON.stringify(swaggerJson))];
+                    case 2:
+                        _g.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _g.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        generatedContent = _g.sent();
+                        parsed = parseDataSourcesInfo(generatedContent);
+                        // Verify the data source exists with sanitized name (hyphens become underscores)
+                        (0, globals_2.expect)(parsed).toHaveProperty('users_api');
+                        dataSource = parsed.users_api;
+                        // Verify APIs are generated correctly
+                        (0, globals_2.expect)(dataSource.apis).toHaveProperty('GetUsers');
+                        (0, globals_2.expect)(dataSource.apis).toHaveProperty('CreateUser');
+                        getUsersApi = dataSource.apis.GetUsers;
+                        (0, globals_2.expect)(getUsersApi.path).toBe('/users');
+                        (0, globals_2.expect)(getUsersApi.method).toBe('GET');
+                        (0, globals_2.expect)(getUsersApi.parameters).toBeDefined();
+                        (0, globals_2.expect)((_a = getUsersApi.parameters) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                        (0, globals_2.expect)((_b = getUsersApi.parameters) === null || _b === void 0 ? void 0 : _b[0].name).toBe('limit');
+                        (0, globals_2.expect)((_d = (_c = getUsersApi.responseInfo) === null || _c === void 0 ? void 0 : _c['200']) === null || _d === void 0 ? void 0 : _d.type).toBe('array');
+                        createUserApi = dataSource.apis.CreateUser;
+                        (0, globals_2.expect)(createUserApi.path).toBe('/users');
+                        (0, globals_2.expect)(createUserApi.method).toBe('POST');
+                        (0, globals_2.expect)((_f = (_e = createUserApi.responseInfo) === null || _e === void 0 ? void 0 : _e['201']) === null || _f === void 0 ? void 0 : _f.type).toBe('void');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, globals_1.it)('should handle swagger with parameter references', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, swaggerJson, outputPath, generatedContent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/folder';
+                        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',
+                                        },
+                                    },
+                                },
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'swagger-ref.json'), JSON.stringify(swaggerJson))];
+                    case 2:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _a.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        generatedContent = _a.sent();
+                        (0, globals_2.expect)(generatedContent).toContain('items_api');
+                        (0, globals_2.expect)(generatedContent).toContain('GetItems');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, globals_1.it)('should handle responses with schema references', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, swaggerJson, outputPath, generatedContent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/folder';
+                        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',
+                                        },
+                                    },
+                                },
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'models.json'), JSON.stringify(swaggerJson))];
+                    case 2:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _a.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        generatedContent = _a.sent();
+                        (0, globals_2.expect)(generatedContent).toContain('GetModels');
+                        (0, globals_2.expect)(generatedContent).toContain('"type": "object"');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    (0, globals_1.describe)('SQL stored procedure processing', function () {
+        (0, globals_1.it)('should process SQL stored procedure with input parameters', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, procedureJson, outputPath, generatedContent, parsed, dataSource, procApi, paramNames;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        folderPath = '/test/procedures/GetUserById';
+                        procedureJson = {
+                            name: '[dbo].[GetUserById]',
+                            schema: {
+                                procedureresultschema: {
+                                    type: 'object',
+                                },
+                                inputparameters: {
+                                    properties: {
+                                        UserId: {
+                                            type: 'integer',
+                                            required: true,
+                                        },
+                                        IncludeDetails: {
+                                            type: 'boolean',
+                                            required: false,
+                                        },
+                                    },
+                                },
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _c.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'procedure.json'), JSON.stringify(procedureJson))];
+                    case 2:
+                        _c.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _c.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        generatedContent = _c.sent();
+                        parsed = parseDataSourcesInfo(generatedContent);
+                        // Verify the data source exists (uses parent folder name as key)
+                        (0, globals_2.expect)(parsed).toHaveProperty('getuserbyid');
+                        dataSource = parsed.getuserbyid;
+                        // Verify the stored procedure API
+                        (0, globals_2.expect)(dataSource.apis).toHaveProperty('GetUserById');
+                        procApi = dataSource.apis.GetUserById;
+                        (0, globals_2.expect)(procApi.path).toBe('/dbo.GetUserById');
+                        (0, globals_2.expect)(procApi.method).toBe('POST');
+                        // Verify parameters are present
+                        (0, globals_2.expect)(procApi.parameters).toBeDefined();
+                        paramNames = (_b = (_a = procApi.parameters) === null || _a === void 0 ? void 0 : _a.map(function (p) { return p.name; })) !== null && _b !== void 0 ? _b : [];
+                        (0, globals_2.expect)(paramNames).toContain('UserId');
+                        (0, globals_2.expect)(paramNames).toContain('IncludeDetails');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, globals_1.it)('should handle stored procedure without input parameters', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, procedureJson, outputPath, generatedContent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/procedures/GetAllUsers';
+                        procedureJson = {
+                            name: '[dbo].[GetAllUsers]',
+                            schema: {
+                                procedureresultschema: {
+                                    type: 'array',
+                                },
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'procedure.json'), JSON.stringify(procedureJson))];
+                    case 2:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _a.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        generatedContent = _a.sent();
+                        (0, globals_2.expect)(generatedContent).toContain('getallusers');
+                        (0, globals_2.expect)(generatedContent).toContain('"/dbo.GetAllUsers"');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, globals_1.it)('should determine property key from parent folder for stored procedures', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, procedureJson, outputPath, generatedContent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/procedures/UserProcedures';
+                        procedureJson = {
+                            name: '[dbo].[GetUser]',
+                            schema: {
+                                procedureresultschema: {
+                                    type: 'object',
+                                },
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'procedure.json'), JSON.stringify(procedureJson))];
+                    case 2:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _a.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        generatedContent = _a.sent();
+                        (0, globals_2.expect)(generatedContent).toContain('userprocedures');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, globals_1.it)('should handle non-dbo schemas', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, procedureJson, outputPath, generatedContent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/procedures/GetAllUsers';
+                        procedureJson = {
+                            name: '[foo].[GetAllUsers]',
+                            schema: {
+                                procedureresultschema: {
+                                    type: 'array',
+                                },
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'procedure.json'), JSON.stringify(procedureJson))];
+                    case 2:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _a.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        generatedContent = _a.sent();
+                        (0, globals_2.expect)(generatedContent).toContain('getallusers');
+                        (0, globals_2.expect)(generatedContent).toContain('"/foo.GetAllUsers"');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    (0, globals_1.describe)('SQL table processing', function () {
+        (0, globals_1.it)('should process SQL table schema with primary key', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, tableJson, outputPath, generatedContent, parsed, expectedKey, dataSource;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/tables';
+                        tableJson = {
+                            name: '[dbo].[Users]',
+                            schema: {
+                                items: {
+                                    properties: {
+                                        Id: {
+                                            type: 'integer',
+                                            'x-ms-keyType': 'primary',
+                                        },
+                                        Name: {
+                                            type: 'string',
+                                        },
+                                        Email: {
+                                            type: 'string',
+                                        },
+                                    },
+                                },
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'users.json'), JSON.stringify(tableJson))];
+                    case 2:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _a.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        generatedContent = _a.sent();
+                        parsed = parseDataSourcesInfo(generatedContent);
+                        expectedKey = '_dbo___users_';
+                        (0, globals_2.expect)(parsed).toHaveProperty(expectedKey);
+                        dataSource = parsed[expectedKey];
+                        // Verify SQL table properties - tableId gets the cleaned name from sanitizeSqlName
+                        (0, globals_2.expect)(dataSource.tableId).toBe('Users');
+                        (0, globals_2.expect)(dataSource.version).toBe('v2');
+                        (0, globals_2.expect)(dataSource.primaryKey).toBe('Id');
+                        (0, globals_2.expect)(dataSource.dataSourceType).toBe('Connector');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, globals_1.it)('should handle table without primary key', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, tableJson, outputPath, generatedContent, parsed, expectedKey, dataSource;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/sql/tables';
+                        tableJson = {
+                            name: '[dbo].[Logs]',
+                            schema: {
+                                items: {
+                                    properties: {
+                                        Message: {
+                                            type: 'string',
+                                        },
+                                        Timestamp: {
+                                            type: 'string',
+                                        },
+                                    },
+                                },
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'logs.json'), JSON.stringify(tableJson))];
+                    case 2:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _a.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        generatedContent = _a.sent();
+                        parsed = parseDataSourcesInfo(generatedContent);
+                        expectedKey = 'logs';
+                        (0, globals_2.expect)(parsed).toHaveProperty(expectedKey);
+                        dataSource = parsed[expectedKey];
+                        // Verify primary key is empty when not specified
+                        (0, globals_2.expect)(dataSource.tableId).toBe('Logs');
+                        (0, globals_2.expect)(dataSource.primaryKey).toBe('');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    (0, globals_1.describe)('Property key determination', function () {
+        (0, globals_1.it)('should remove [dbo]. prefix and brackets from SQL table names', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, tableJson, outputPath, generatedContent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/tables';
+                        tableJson = {
+                            name: '[dbo].[ComplexTableName]',
+                            schema: {
+                                items: {
+                                    properties: {},
+                                },
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'table.json'), JSON.stringify(tableJson))];
+                    case 2:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _a.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        generatedContent = _a.sent();
+                        (0, globals_2.expect)(generatedContent).toContain('ComplexTableName');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, globals_1.it)('should remove [custom_schema]. prefix and brackets from SQL table names', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, tableJson, outputPath, generatedContent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/tables';
+                        tableJson = {
+                            name: '[custom_schema].[ComplexTableName]',
+                            schema: {
+                                items: {
+                                    properties: {},
+                                },
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'table.json'), JSON.stringify(tableJson))];
+                    case 2:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _a.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        generatedContent = _a.sent();
+                        (0, globals_2.expect)(generatedContent).toContain('ComplexTableName');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, globals_1.it)('should remove shared_ prefix from non-tabular names', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, sharedJson, outputPath, generatedContent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/shared';
+                        sharedJson = {
+                            name: 'shared_commonservice',
+                            properties: {
+                                displayName: 'CommonService',
+                            },
+                            schema: {
+                                type: 'object',
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'service.json'), JSON.stringify(sharedJson))];
+                    case 2:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _a.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        generatedContent = _a.sent();
+                        (0, globals_2.expect)(generatedContent).toContain('commonservice');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, globals_1.it)('should use title property when available', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, tabularJson, outputPath, generatedContent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/tabular';
+                        tabularJson = {
+                            title: 'UserManagement',
+                            name: 'internal_name',
+                            schema: {
+                                type: 'object',
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'service.json'), JSON.stringify(tabularJson))];
+                    case 2:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _a.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        generatedContent = _a.sent();
+                        (0, globals_2.expect)(generatedContent).toContain('internal_name');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, globals_1.it)('should fallback to filename when name property is missing', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, jsonWithoutName, outputPath, generatedContent, parsed, expectedKey;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/fallback';
+                        jsonWithoutName = {
+                            schema: {
+                                type: 'object',
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'FallbackService.Schema.json'), JSON.stringify(jsonWithoutName))];
+                    case 2:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _a.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        generatedContent = _a.sent();
+                        parsed = parseDataSourcesInfo(generatedContent);
+                        expectedKey = 'fallbackservice.schema';
+                        (0, globals_2.expect)(parsed).toHaveProperty([expectedKey]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, globals_1.it)('should handle names with spaces and underscores', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, complexNameJson, outputPath, generatedContent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/complexnames';
+                        complexNameJson = {
+                            name: '  Complex_Name With Spaces  ',
+                            title: '  Complex_Name With Spaces  ',
+                            schema: {
+                                type: 'object',
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'complex.json'), JSON.stringify(complexNameJson))];
+                    case 2:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _a.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        generatedContent = _a.sent();
+                        // Keys are now lowercase
+                        (0, globals_2.expect)(generatedContent).toContain('complex_namewithspaces');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, globals_1.it)('should use name property for SharePoint list with underscores and hyphens', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, sharepointListJson, outputPath, generatedContent, parsed, expectedKey, dataSource;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/sharepointspecialname';
+                        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',
+                                    },
+                                },
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'speciallist.json'), JSON.stringify(sharepointListJson))];
+                    case 2:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _a.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        generatedContent = _a.sent();
+                        parsed = parseDataSourcesInfo(generatedContent);
+                        expectedKey = 'pakempar_listwithunderscores_andhype_ns';
+                        (0, globals_2.expect)(parsed).toHaveProperty(expectedKey);
+                        dataSource = parsed[expectedKey];
+                        // tableId should preserve the original name from the schema
+                        (0, globals_2.expect)(dataSource.tableId).toBe('PaKeMpar_list with underscores-and hype-ns');
+                        (0, globals_2.expect)(dataSource.primaryKey).toBe('ID');
+                        (0, globals_2.expect)(dataSource.dataSourceType).toBe('Connector');
+                        // Should have APIs generated from referencedEntities
+                        (0, globals_2.expect)(dataSource.apis).toHaveProperty('GetAuthor');
+                        (0, globals_2.expect)(dataSource.apis).toHaveProperty('GetEditor');
+                        // Verify API paths have GUIDs without hyphens
+                        (0, globals_2.expect)(dataSource.apis.GetAuthor.path).toContain('e34fc1b57e29473a9863553afa820351');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    (0, globals_1.describe)('Merge functionality', function () {
+        (0, globals_1.it)('should merge APIs when processing multiple files for same data source', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, api1Json, api2Json, outputPath, generatedContent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/merge';
+                        api1Json = {
+                            name: 'shared_testservice',
+                            type: 'Microsoft.PowerApps/apis',
+                            properties: {
+                                displayName: 'TestService',
+                                swagger: {
+                                    paths: {
+                                        '/api1': {
+                                            get: {
+                                                operationId: 'GetApi1',
+                                                responses: { '200': { description: 'Success' } },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        };
+                        api2Json = {
+                            name: 'shared_testservice',
+                            type: 'Microsoft.PowerApps/apis',
+                            properties: {
+                                displayName: 'TestService',
+                                swagger: {
+                                    paths: {
+                                        '/api2': {
+                                            post: {
+                                                operationId: 'PostApi2',
+                                                responses: { '201': { description: 'Created' } },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'api1.json'), JSON.stringify(api1Json))];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'api2.json'), JSON.stringify(api2Json))];
+                    case 3:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 4:
+                        // Act
+                        _a.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 5:
+                        generatedContent = _a.sent();
+                        (0, globals_2.expect)(generatedContent).toContain('GetApi1');
+                        (0, globals_2.expect)(generatedContent).toContain('PostApi2');
+                        (0, globals_2.expect)(generatedContent).toContain('testservice');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, globals_1.it)('should handle duplicate stored procedures gracefully', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, procedureJson;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/duplicate';
+                        procedureJson = {
+                            name: '[dbo].[DuplicateProc]',
+                            schema: {
+                                procedureresultschema: { type: 'object' },
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'proc1.json'), JSON.stringify(procedureJson))];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'proc2.json'), JSON.stringify(procedureJson))];
+                    case 3:
+                        _a.sent();
+                        // Act & Assert
+                        // Note: The current implementation merges APIs instead of throwing an error
+                        // This test verifies that duplicate stored procedures are handled gracefully
+                        return [4 /*yield*/, (0, globals_2.expect)((0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)).resolves.not.toThrow()];
+                    case 4:
+                        // Act & Assert
+                        // Note: The current implementation merges APIs instead of throwing an error
+                        // This test verifies that duplicate stored procedures are handled gracefully
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    (0, globals_1.describe)('Response processing', function () {
+        (0, globals_1.it)('should handle array responses correctly', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, swaggerJson, outputPath, generatedContent, parsed, dataSource, getArrayApi;
+            var _a, _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        folderPath = '/test/responses';
+                        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',
+                                                        },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _e.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'array-response.json'), JSON.stringify(swaggerJson))];
+                    case 2:
+                        _e.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _e.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        generatedContent = _e.sent();
+                        parsed = parseDataSourcesInfo(generatedContent);
+                        // Verify the data source exists with sanitized name
+                        (0, globals_2.expect)(parsed).toHaveProperty('array_api');
+                        dataSource = parsed.array_api;
+                        getArrayApi = dataSource.apis.GetArray;
+                        (0, globals_2.expect)((_b = (_a = getArrayApi.responseInfo) === null || _a === void 0 ? void 0 : _a['200']) === null || _b === void 0 ? void 0 : _b.type).toBe('array');
+                        (0, globals_2.expect)((_d = (_c = getArrayApi.responseInfo) === null || _c === void 0 ? void 0 : _c['200']) === null || _d === void 0 ? void 0 : _d.format).toBe('custom');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, globals_1.it)('should handle void responses when no schema provided', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, swaggerJson, outputPath, generatedContent, parsed, dataSource, deleteApi;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        folderPath = '/test/responses';
+                        swaggerJson = {
+                            name: 'void-api',
+                            type: 'Microsoft.PowerApps/apis',
+                            properties: {
+                                swagger: {
+                                    paths: {
+                                        '/void-endpoint': {
+                                            delete: {
+                                                operationId: 'DeleteItem',
+                                                responses: {
+                                                    '204': {
+                                                        description: 'No Content',
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _c.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'void-response.json'), JSON.stringify(swaggerJson))];
+                    case 2:
+                        _c.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _c.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        generatedContent = _c.sent();
+                        parsed = parseDataSourcesInfo(generatedContent);
+                        // Verify the data source exists with sanitized name
+                        (0, globals_2.expect)(parsed).toHaveProperty('void_api');
+                        dataSource = parsed.void_api;
+                        deleteApi = dataSource.apis.DeleteItem;
+                        (0, globals_2.expect)((_b = (_a = deleteApi.responseInfo) === null || _a === void 0 ? void 0 : _a['204']) === null || _b === void 0 ? void 0 : _b.type).toBe('void');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    (0, globals_1.describe)('Error handling', function () {
+        (0, globals_1.it)('should throw descriptive error for invalid JSON structure', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, invalidJson;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/invalid';
+                        invalidJson = {
+                            invalidStructure: true,
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'invalid.json'), JSON.stringify(invalidJson))];
+                    case 2:
+                        _a.sent();
+                        // Act & Assert
+                        return [4 /*yield*/, (0, globals_2.expect)((0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)).rejects.toThrow('The JSON does not represent a valid data source')];
+                    case 3:
+                        // Act & Assert
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, globals_1.it)('should handle nested directory traversal', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, subfolderPath, nestedJson, outputPath, outputExists;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/nested';
+                        subfolderPath = mockVfs_1.default.join(folderPath, 'subfolder');
+                        nestedJson = {
+                            name: 'nested-service',
+                            schema: { type: 'object' },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(subfolderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(subfolderPath, 'nested.json'), JSON.stringify(nestedJson))];
+                    case 2:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _a.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.exists(outputPath)];
+                    case 4:
+                        outputExists = _a.sent();
+                        (0, globals_2.expect)(outputExists).toBe(true);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    (0, globals_1.describe)('Parameter sorting', function () {
+        (0, globals_1.it)('should sort parameters with required first', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, swaggerJson, outputPath, generatedContent, parsed, dataSource, operation, parameters;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/sorting';
+                        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' },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'sorted.json'), JSON.stringify(swaggerJson))];
+                    case 2:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _a.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        generatedContent = _a.sent();
+                        parsed = parseDataSourcesInfo(generatedContent);
+                        // Verify data source exists with sanitized name
+                        (0, globals_2.expect)(parsed).toHaveProperty('sorting_api');
+                        dataSource = parsed.sorting_api;
+                        operation = dataSource.apis.PostWithSortedParams;
+                        parameters = operation.parameters;
+                        // Required parameters should come first
+                        (0, globals_2.expect)(parameters === null || parameters === void 0 ? void 0 : parameters[0].required).toBe(true);
+                        (0, globals_2.expect)(parameters === null || parameters === void 0 ? void 0 : parameters[1].required).toBe(true);
+                        (0, globals_2.expect)(parameters === null || parameters === void 0 ? void 0 : parameters[2].required).toBe(false);
+                        (0, globals_2.expect)(parameters === null || parameters === void 0 ? void 0 : parameters[3].required).toBe(false);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    (0, globals_1.describe)('Output generation', function () {
+        (0, globals_1.it)('should generate properly formatted TypeScript output', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var folderPath, simpleJson, outputPath, content;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        folderPath = '/test/output';
+                        simpleJson = {
+                            name: 'test-service',
+                            schema: { type: 'object' },
+                        };
+                        return [4 /*yield*/, mockVfs_1.default.mkdir(folderPath, { recursive: true })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, mockVfs_1.default.writeFile(mockVfs_1.default.join(folderPath, 'simple.json'), JSON.stringify(simpleJson))];
+                    case 2:
+                        _a.sent();
+                        // Act
+                        return [4 /*yield*/, (0, dataSourceInfoProcessor_1.processDataSourceInfo)(folderPath, mockLogger)];
+                    case 3:
+                        // Act
+                        _a.sent();
+                        outputPath = mockVfs_1.default.join(folderPath, 'appschemas', 'dataSourcesInfo.ts');
+                        return [4 /*yield*/, mockVfs_1.default.readFile(outputPath)];
+                    case 4:
+                        content = _a.sent();
+                        (0, globals_2.expect)(content).toContain('/*!');
+                        (0, globals_2.expect)(content).toContain(' * Copyright (C) Microsoft Corporation. All rights reserved.');
+                        (0, globals_2.expect)(content).toContain(' * This file is auto-generated. Do not modify it manually.');
+                        (0, globals_2.expect)(content).toContain('export const dataSourcesInfo = ');
+                        (0, globals_2.expect)(content).toMatch(/;\s*$/); // Should end with semicolon
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});
 //# sourceMappingURL=DataSourceInfoProcessor.spec.js.map