vogen crypto-targets.json convert javaVo.java
#!/usr/bin/env node
const fs = require('fs');
const path = require('path');
const DEST_COLUMN_KEYS = [
'encColumn',
'encryptColumn',
'encryptedColumn',
'cryptoColumn',
'destColumn',
'hashColumn'
];
function printUsage() {
console.log([
'Usage:',
' node vogen/index.js [crypto-targets-json-path] [output-txt-path]',
'',
'Defaults:',
' input : ./crypto-targets.json',
' output: ./output.txt'
].join('\n'));
}
function readJson(filePath) {
const raw = fs.readFileSync(filePath, 'utf8').replace(/^\uFEFF/, '');
return JSON.parse(raw);
}
function requireString(target, key, index) {
const value = target[key];
if (typeof value !== 'string' || value.trim() === '') {
throw new Error(`Target #${index} is missing "${key}".`);
}
return value.trim();
}
function findDestColumn(target, index) {
for (const key of DEST_COLUMN_KEYS) {
const value = target[key];
if (typeof value === 'string' && value.trim() !== '') {
return value.trim();
}
}
throw new Error(
`Target #${index} is missing destination column. Expected one of: ${DEST_COLUMN_KEYS.join(', ')}.`
);
}
function groupTargets(targets) {
const groups = [];
const groupByTableName = new Map();
targets.forEach((target, offset) => {
const sourceNo = offset + 1;
const tableName = requireString(target, 'tableName', sourceNo);
const plainColumn = requireString(target, 'plainColumn', sourceNo);
const cryptoType = requireString(target, 'cryptoType', sourceNo);
const destColumn = findDestColumn(target, sourceNo);
if (!groupByTableName.has(tableName)) {
const group = {
tableName,
sourceNos: [],
plainColumns: [],
destColumns: [],
cryptoTypes: []
};
groupByTableName.set(tableName, group);
groups.push(group);
}
const group = groupByTableName.get(tableName);
group.sourceNos.push(sourceNo);
group.plainColumns.push(plainColumn);
group.destColumns.push(destColumn);
group.cryptoTypes.push(cryptoType);
});
return groups;
}
function quoteJavaString(value) {
return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
}
function formatArrayDeclaration(name, values, comments, options = {}) {
const lines = [];
if (options.annotation) {
lines.push(options.annotation);
}
lines.push(`private String[] ${name} = {`);
values.forEach((value, index) => {
const comma = index === values.length - 1 ? '' : ',';
lines.push(` ${quoteJavaString(value)}${comma}//${comments[index]}`);
});
lines.push('};');
return lines.join('\n');
}
function buildOutput(groups) {
const comments = groups.map((group) => group.sourceNos.join(','));
return [
formatArrayDeclaration('tableLists', groups.map((group) => group.tableName), comments),
'',
formatArrayDeclaration(
'srcColLists',
groups.map((group) => group.plainColumns.join(',')),
comments,
{ annotation: '@Override' }
),
'',
formatArrayDeclaration('destColLists', groups.map((group) => group.destColumns.join(',')), comments),
'',
formatArrayDeclaration('typeLists', groups.map((group) => group.cryptoTypes.join(',')), comments),
''
].join('\n');
}
function main() {
const args = process.argv.slice(2);
if (args.includes('-h') || args.includes('--help')) {
printUsage();
return;
}
const inputPath = path.resolve(process.cwd(), args[0] || 'crypto-targets.json');
const outputPath = path.resolve(process.cwd(), args[1] || 'output.txt');
const targets = readJson(inputPath);
if (!Array.isArray(targets)) {
throw new Error(`Input JSON must be an array: ${inputPath}`);
}
const output = buildOutput(groupTargets(targets));
fs.writeFileSync(outputPath, output, 'utf8');
console.log(`Generated ${outputPath}`);
}
try {
main();
} catch (error) {
console.error(error.message);
process.exit(1);
}
댓글
댓글 쓰기