vo
gen
import fs from 'fs';
import path from 'path';
const DEFAULT_DEST_COLUMN_KEYS = [
'encColumn',
'encryptColumn',
'encryptedColumn',
'cryptoColumn',
'destColumn',
'hashColumn'
];
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();
}
export function getOptionalString(target, key) {
const value = target[key];
return typeof value === 'string' && value.trim() !== '' ? value.trim() : '';
}
function findDestColumn(target, index, destColumnKeys) {
for (const key of destColumnKeys) {
const value = getOptionalString(target, key);
if (value) {
return value;
}
}
throw new Error(
`Target #${index} is missing destination column. Expected one of: ${destColumnKeys.join(', ')}.`
);
}
function groupTargets(targets, options = {}) {
const destColumnKeys = options.destColumnKeys || DEFAULT_DEST_COLUMN_KEYS;
const groups = [];
const groupByTableName = new Map();
targets.forEach((target, offset) => {
const sourceNo = offset + 1;
if (options.filter && !options.filter(target, sourceNo)) {
return;
}
const tableName = requireString(target, 'tableName', sourceNo);
const plainColumn = requireString(target, 'plainColumn', sourceNo);
const cryptoType = requireString(target, 'cryptoType', sourceNo);
const destColumn = findDestColumn(target, sourceNo, destColumnKeys);
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');
}
export function generate(options) {
const inputPath = path.resolve(process.cwd(), options.inputPath);
const outputPath = path.resolve(process.cwd(), options.outputPath);
const targets = readJson(inputPath);
if (!Array.isArray(targets)) {
throw new Error(`Input JSON must be an array: ${inputPath}`);
}
const output = buildOutput(groupTargets(targets, options));
fs.writeFileSync(outputPath, output, 'utf8');
return outputPath;
}
===============
index.hash.js
#!/usr/bin/env node
import { fileURLToPath } from 'url';
import { generate, getOptionalString } from './generator.js';
const DEFAULT_SQL_QUERY_XML_PATH = fileURLToPath(new URL('./sqlquery.xml', import.meta.url));
function printUsage() {
console.log([
'Usage:',
' node vogen/index.hash.js [crypto-targets-json-path] [output-hash-txt-path] [sqlquery-xml-path]',
'',
'Defaults:',
' input : ./crypto-targets.json',
' output: ./output.hash.txt',
' sql : ./vogen/sqlquery.xml'
].join('\n'));
}
function main() {
const args = process.argv.slice(2);
if (args.includes('-h') || args.includes('--help')) {
printUsage();
return;
}
const result = generate({
inputPath: args[0] || 'crypto-targets.json',
outputPath: args[1] || 'output.hash.txt',
sqlQueryXmlPath: args[2] || DEFAULT_SQL_QUERY_XML_PATH,
destColumnKeys: ['hashColumn'],
renumberSourceNos: true,
filter: (target) => Boolean(getOptionalString(target, 'hashColumn'))
});
console.log(`Generated ${result.outputPath}`);
console.log(`SQL query XML: ${result.sqlQueryXmlPath}`);
console.log(`Table groups: ${result.groupCount}`);
}
try {
main();
} catch (error) {
console.error(error.message);
process.exit(1);
}
==============
index.js
#!/usr/bin/env node
import { generate } from './generator.js';
function printUsage() {
console.log([
'Usage:',
' node vogen/index.js [crypto-targets-json-path] [output-txt-path] [sqlquery-xml-path]',
'',
'Defaults:',
' input : ./crypto-targets.json',
' output: ./output.txt',
' sql : ./vogen/sqlquery.xml'
].join('\n'));
}
function main() {
const args = process.argv.slice(2);
if (args.includes('-h') || args.includes('--help')) {
printUsage();
return;
}
const outputPath = generate({
inputPath: args[0] || 'crypto-targets.json',
outputPath: args[1] || 'output.txt',
sqlQueryXmlPath: args[2] ||"sqlquery.xml"
});
console.log(`Generated ${outputPath}`);
}
try {
main();
} catch (error) {
console.error(error.message);
process.exit(1);
}
댓글
댓글 쓰기