@msugiura/rawsql-prisma
Version:
Prisma integration for rawsql-ts - Dynamic SQL generation with type safety and hierarchical JSON serialization
221 lines ā¢ 8.75 kB
JavaScript
;
/**
* Generic Domain Model Compatibility Test Helper
*
* Provides utility functions for automatically testing JsonMapping compatibility
* with TypeScript interfaces using only interface name and import path.
*/
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.DomainModelCompatibilityTester = void 0;
exports.validateJsonMappingCompatibility = validateJsonMappingCompatibility;
const AutoTypeCompatibilityValidator_1 = require("./AutoTypeCompatibilityValidator");
const fs = __importStar(require("fs"));
const path = __importStar(require("path"));
/**
* Generic test helper for domain model compatibility validation
*/
class DomainModelCompatibilityTester {
constructor(options = {}) {
// Use project current directory for proper path resolution
const defaultBaseDir = process.cwd();
this.options = {
baseDir: defaultBaseDir,
mappingDir: './rawsql-ts',
debug: false,
...options
};
this.validator = new AutoTypeCompatibilityValidator_1.AutoTypeCompatibilityValidator({
baseDir: this.options.baseDir,
debug: this.options.debug
});
}
/**
* Validate a single JsonMapping file against its specified interface
*
* @param mappingFileName - Name of the JsonMapping file (e.g., 'getTodoDetail.json')
* @returns Promise<{ isValid: boolean, errors: string[], details: any }>
*/
async validateMappingFile(mappingFileName) {
const mappingPath = path.join(this.options.mappingDir, mappingFileName);
if (!fs.existsSync(mappingPath)) {
return {
isValid: false,
errors: [`JsonMapping file not found: ${mappingPath}`],
details: null
};
}
try {
// Load JsonMapping
const mappingContent = fs.readFileSync(mappingPath, 'utf8');
const jsonMapping = JSON.parse(mappingContent);
if (!jsonMapping.typeInfo) {
return {
isValid: false,
errors: ['No typeInfo specified in JsonMapping. Add typeInfo with interface and importPath.'],
details: null
};
}
if (this.options.debug) {
console.log(`š Validating ${mappingFileName}:`);
console.log(` Interface: ${jsonMapping.typeInfo.interface}`);
console.log(` Import: ${jsonMapping.typeInfo.importPath}`);
}
// Validate using AutoTypeCompatibilityValidator
const result = await this.validator.validateMapping(jsonMapping);
return {
isValid: result.isValid,
errors: result.errors,
details: {
missingProperties: result.missingProperties,
extraProperties: result.extraProperties,
typeConflicts: result.typeConflicts
}
};
}
catch (error) {
return {
isValid: false,
errors: [`Failed to process JsonMapping: ${error instanceof Error ? error.message : String(error)}`],
details: null
};
}
}
/**
* Validate all JsonMapping files in the mapping directory
*
* @returns Promise<{ [fileName: string]: ValidationResult }>
*/
async validateAllMappingFiles() {
const mappingDir = this.options.mappingDir;
if (!fs.existsSync(mappingDir)) {
return {
error: `Mapping directory not found: ${mappingDir}`
};
}
const files = fs.readdirSync(mappingDir);
const jsonFiles = files.filter(file => file.endsWith('.json'));
const results = {};
for (const jsonFile of jsonFiles) {
if (this.options.debug) {
console.log(`\nš Processing ${jsonFile}...`);
}
results[jsonFile] = await this.validateMappingFile(jsonFile);
}
return results;
}
/**
* Generate a vitest test case for a specific JsonMapping file
*
* Usage in test files:
* ```typescript
* const tester = new DomainModelCompatibilityTester({ debug: true });
*
* it('should validate getTodoDetail JsonMapping compatibility', async () => {
* await tester.generateTestCase('getTodoDetail.json');
* });
* ```
*/
async generateTestCase(mappingFileName) {
const result = await this.validateMappingFile(mappingFileName);
// Use expect from vitest/jest
const { expect } = await Promise.resolve().then(() => __importStar(require('vitest')));
expect(result.isValid).toBe(true);
if (result.errors.length > 0) {
expect.fail(`JsonMapping compatibility validation failed for ${mappingFileName}:\n${result.errors.join('\n')}`);
}
if (result.details) {
expect(result.details.missingProperties).toHaveLength(0);
expect(result.details.extraProperties).toHaveLength(0);
expect(result.details.typeConflicts).toHaveLength(0);
}
// Return result for additional assertions if needed
return result;
}
/**
* Create a comprehensive test suite for all JsonMapping files
*
* Usage:
* ```typescript
* describe('Domain Model Compatibility Tests', () => {
* const tester = new DomainModelCompatibilityTester();
* tester.createTestSuite();
* });
* ```
*/
createTestSuite() {
const { describe, it } = require('vitest');
const mappingDir = this.options.mappingDir;
describe('Auto-generated JsonMapping Compatibility Tests', () => {
if (!fs.existsSync(mappingDir)) {
it('should find mapping directory', () => {
throw new Error(`Mapping directory not found: ${mappingDir}`);
});
return;
}
const files = fs.readdirSync(mappingDir);
const jsonFiles = files.filter(file => file.endsWith('.json'));
if (jsonFiles.length === 0) {
it('should find JsonMapping files', () => {
throw new Error(`No .json files found in ${mappingDir}`);
});
return;
}
for (const jsonFile of jsonFiles) {
it(`should validate ${jsonFile} compatibility with TypeScript interface`, async () => {
await this.generateTestCase(jsonFile);
});
}
});
}
}
exports.DomainModelCompatibilityTester = DomainModelCompatibilityTester;
/**
* Convenience function for quick validation in tests
*
* Usage:
* ```typescript
* import { validateJsonMappingCompatibility } from './DomainModelCompatibilityTester';
*
* it('should validate getTodoDetail compatibility', async () => {
* await validateJsonMappingCompatibility('getTodoDetail.json');
* });
* ```
*/
async function validateJsonMappingCompatibility(mappingFileName, options = {}) {
const tester = new DomainModelCompatibilityTester(options);
return await tester.generateTestCase(mappingFileName);
}
//# sourceMappingURL=DomainModelCompatibilityTester.js.map