birc-generator 0.9.1 → 1.0.0

package/lib/make.js

@@ -0,0 +1,658 @@
+const fs = require('fs');
+const path = require('path');
+const VERSIONS = require('../versions');
+const { toPascalCaseName } = require('../bin/cli-util');
+const {
+  loadProjectConfig,
+  resolvePersistence,
+  projectRoot
+} = require('./project');
+
+const DEFAULT_STRING_COLUMN_LENGTH = 50;
+
+function parseFields(fields) {
+  if (!fields || !String(fields).trim()) {
+    return [];
+  }
+  return String(fields)
+    .split(',')
+    .map((f) => {
+      const [name, type] = f.split(':');
+      const fieldName = (name || '').trim();
+      const fieldType = (type || 'String').trim();
+      return {
+        name: fieldName,
+        type: fieldType,
+        snakeName: fieldName
+          .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+          .replace(/[\s-]+/g, '_')
+          .toLowerCase(),
+        columnLength: fieldType === 'String' ? DEFAULT_STRING_COLUMN_LENGTH : null
+      };
+    })
+    .filter((f) => f.name);
+}
+
+function isExample(data) {
+  return Boolean(data && data.example)
+    || process.env.BIRC_EXAMPLE === '1'
+    || parseFields((data && data.fields) || process.env.BIRC_MAKE_FIELDS).length > 0;
+}
+
+function includeMapperWithEntity(data) {
+  return Boolean(data && (data.dto || data.mapper))
+    || process.env.BIRC_MAKE_DTO === '1'
+    || process.env.BIRC_MAKE_MAPPER === '1';
+}
+
+function includeModelMigration(data) {
+  return Boolean(data && data.migration) || process.env.BIRC_MAKE_MIGRATION === '1';
+}
+
+function includeModelSeed(data) {
+  return Boolean(data && data.seed) || process.env.BIRC_MAKE_SEED === '1';
+}
+
+function skipExistingMakeFiles(data) {
+  return includeModelMigration(data) || includeModelSeed(data);
+}
+
+function includeModelController(data) {
+  return Boolean(data && data.controller) || process.env.BIRC_MAKE_CONTROLLER === '1';
+}
+
+function includeSoftDelete(data) {
+  return Boolean(data && data.softDelete) || process.env.BIRC_MAKE_SOFT_DELETE === '1';
+}
+
+function toSnakeCase(text) {
+  return String(text || '')
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .replace(/[\s-]+/g, '_')
+    .toLowerCase();
+}
+
+function tableNameFromEntity(entityName) {
+  return toSnakeCase(entityName);
+}
+
+const JAVA_SQL_TYPES = Object.freeze({
+  String: `VARCHAR(${DEFAULT_STRING_COLUMN_LENGTH}) NULL`,
+  Integer: 'INT NULL',
+  int: 'INT NULL',
+  Long: 'BIGINT NULL',
+  long: 'BIGINT NULL',
+  Boolean: 'TINYINT(1) NULL',
+  boolean: 'TINYINT(1) NULL',
+  BigDecimal: 'DECIMAL(19, 2) NULL',
+  LocalDate: 'DATE NULL',
+  LocalDateTime: 'TIMESTAMP NULL',
+  Instant: 'TIMESTAMP NULL',
+  Double: 'DOUBLE NULL',
+  double: 'DOUBLE NULL',
+  Float: 'FLOAT NULL',
+  float: 'FLOAT NULL',
+  Short: 'SMALLINT NULL',
+  short: 'SMALLINT NULL',
+  Byte: 'TINYINT NULL',
+  byte: 'TINYINT NULL'
+});
+
+function sqlTypeForColumn(javaType, columnName) {
+  if (columnName === 'created_at') {
+    return 'TIMESTAMP DEFAULT CURRENT_TIMESTAMP';
+  }
+  if (columnName === 'updated_at') {
+    return 'TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP';
+  }
+  if (columnName === 'deleted_at') {
+    return 'TIMESTAMP NULL';
+  }
+  return JAVA_SQL_TYPES[javaType] || null;
+}
+
+function fieldsToMigrationColumns(fields, options) {
+  const withTimestamps = Boolean(options && options.withTimestamps);
+  const withSoftDelete = Boolean(options && options.withSoftDelete);
+  const columns = [];
+  const seen = new Set();
+
+  function addColumn(name, javaType) {
+    const columnName = sanitizeMigrationToken(name);
+    if (!columnName || columnName === 'id' || seen.has(columnName)) {
+      return;
+    }
+    const sqlType = sqlTypeForColumn(javaType, columnName);
+    if (!sqlType) {
+      return;
+    }
+    seen.add(columnName);
+    columns.push({ name: columnName, sqlType });
+  }
+
+  for (const field of fields || []) {
+    addColumn(field.snakeName || toSnakeCase(field.name), field.type);
+  }
+  if (withTimestamps) {
+    addColumn('created_at', 'LocalDateTime');
+    addColumn('updated_at', 'LocalDateTime');
+  }
+  if (withSoftDelete) {
+    addColumn('deleted_at', 'LocalDateTime');
+  }
+  return columns;
+}
+
+function listJavaFiles(dir, acc = []) {
+  if (!fs.existsSync(dir)) {
+    return acc;
+  }
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      listJavaFiles(full, acc);
+    } else if (entry.isFile() && entry.name.endsWith('.java')) {
+      acc.push(full);
+    }
+  }
+  return acc;
+}
+
+function parseEntityColumns(source) {
+  const fields = [];
+  const fieldRe =
+    /((?:@\w+(?:\s*\([^)]*\))?\s*)*)private\s+([A-Za-z][A-Za-z0-9_]*)\s+([A-Za-z_][A-Za-z0-9_]*)\s*;/g;
+  let match = fieldRe.exec(source);
+  while (match) {
+    const annotations = match[1] || '';
+    const type = match[2];
+    const name = match[3];
+    const columnAttr = annotations.match(/@Column\s*\(([^)]*)\)/);
+    let snakeName = toSnakeCase(name);
+    if (columnAttr) {
+      const named = columnAttr[1].match(/name\s*=\s*"([^"]+)"/);
+      if (named) {
+        snakeName = named[1];
+      }
+    }
+    fields.push({ name, type, snakeName });
+    match = fieldRe.exec(source);
+  }
+  return {
+    fields,
+    withSoftDelete: /@SoftDelete\b/.test(source)
+  };
+}
+
+function findEntitySourceForTable(tableName, config) {
+  if (!tableName) {
+    return null;
+  }
+  const persistence = resolvePersistence(config);
+  const entityDir = path.join(projectRoot(), persistence.entityRoot);
+  const files = listJavaFiles(entityDir);
+  const escaped = String(tableName).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const tableRe = new RegExp(`@Table\\s*\\([^)]*name\\s*=\\s*"${escaped}"`, 'i');
+  for (const file of files) {
+    const source = fs.readFileSync(file, 'utf8');
+    if (tableRe.test(source)) {
+      return source;
+    }
+  }
+  const className = toPascalCaseName(String(tableName).toLowerCase());
+  if (!className) {
+    return null;
+  }
+  const match = files.find((file) => path.basename(file, '.java') === className);
+  if (!match) {
+    return null;
+  }
+  return fs.readFileSync(match, 'utf8');
+}
+
+function javaLiteralForSeed(javaType) {
+  if (javaType === 'String') {
+    return '"example"';
+  }
+  if (javaType === 'LocalDate') {
+    return 'LocalDate.parse("2020-01-01")';
+  }
+  if (javaType === 'LocalDateTime') {
+    return 'LocalDateTime.parse("2020-01-01T00:00:00")';
+  }
+  if (javaType === 'Instant') {
+    return 'Instant.parse("2020-01-01T00:00:00Z")';
+  }
+  if (javaType === 'BigDecimal') {
+    return 'new BigDecimal("0")';
+  }
+  if (javaType === 'Boolean' || javaType === 'boolean') {
+    return 'false';
+  }
+  if (javaType === 'Long' || javaType === 'long') {
+    return '0L';
+  }
+  if (javaType === 'Integer' || javaType === 'int') {
+    return '0';
+  }
+  if (javaType === 'Short' || javaType === 'short') {
+    return '(short) 0';
+  }
+  if (javaType === 'Byte' || javaType === 'byte') {
+    return '(byte) 0';
+  }
+  if (javaType === 'Double' || javaType === 'double') {
+    return '0D';
+  }
+  if (javaType === 'Float' || javaType === 'float') {
+    return '0F';
+  }
+  if (JAVA_SQL_TYPES[javaType]) {
+    return '0';
+  }
+  return null;
+}
+
+const SKIP_SEED_FIELDS = new Set(['id', 'createdAt', 'updatedAt', 'deletedAt', 'created_at', 'updated_at', 'deleted_at']);
+
+function fieldsToSeedFields(fields) {
+  const result = [];
+  const seen = new Set();
+
+  for (const field of fields || []) {
+    const name = String(field.name || '').trim();
+    const snakeName = field.snakeName || toSnakeCase(name);
+    if (!name || SKIP_SEED_FIELDS.has(name) || SKIP_SEED_FIELDS.has(snakeName) || seen.has(name)) {
+      continue;
+    }
+    const literal = javaLiteralForSeed(field.type);
+    if (!literal) {
+      continue;
+    }
+    seen.add(name);
+    result.push({
+      name,
+      type: field.type,
+      setter: `set${name.charAt(0).toUpperCase()}${name.slice(1)}`,
+      literal
+    });
+  }
+  return result;
+}
+
+function resolveSeedFields(data, tableName, config) {
+  const explicitFields = parseFields(data.fields || process.env.BIRC_MAKE_FIELDS);
+  if (explicitFields.length > 0) {
+    return fieldsToSeedFields(explicitFields);
+  }
+  const source = findEntitySourceForTable(tableName, config);
+  if (source) {
+    return fieldsToSeedFields(parseEntityColumns(source).fields);
+  }
+  if (isExample(data)) {
+    return fieldsToSeedFields([{ name: 'name', type: 'String', snakeName: 'name' }]);
+  }
+  return [];
+}
+
+function entityNameForSeeder(data) {
+  const raw = toPascalCaseName((data && data.entityName) || '');
+  return raw.replace(/Seeder$/, '') || raw;
+}
+
+function resolveCreateTableColumns(data, tableName, config) {
+  const example = isExample(data);
+  const flaggedSoftDelete = includeSoftDelete(data);
+  const explicitFields = parseFields(data.fields || process.env.BIRC_MAKE_FIELDS);
+  if (explicitFields.length > 0) {
+    return fieldsToMigrationColumns(explicitFields, {
+      withTimestamps: example,
+      withSoftDelete: flaggedSoftDelete
+    });
+  }
+  const source = findEntitySourceForTable(tableName, config);
+  if (source) {
+    const entity = parseEntityColumns(source);
+    return fieldsToMigrationColumns(entity.fields, {
+      withTimestamps: false,
+      withSoftDelete: flaggedSoftDelete || entity.withSoftDelete
+    });
+  }
+  if (example) {
+    return fieldsToMigrationColumns(
+      [{ name: 'name', type: 'String', snakeName: 'name' }],
+      { withTimestamps: true, withSoftDelete: flaggedSoftDelete }
+    );
+  }
+  return fieldsToMigrationColumns([], {
+    withTimestamps: false,
+    withSoftDelete: flaggedSoftDelete
+  });
+}
+
+function fieldImports(fields) {
+  const types = new Set((fields || []).map((field) => field.type));
+  const imports = [];
+  if (types.has('LocalDateTime')) imports.push('java.time.LocalDateTime');
+  if (types.has('LocalDate')) imports.push('java.time.LocalDate');
+  if (types.has('Instant')) imports.push('java.time.Instant');
+  if (types.has('BigDecimal')) imports.push('java.math.BigDecimal');
+  return imports;
+}
+
+function resolveMakeFields(data) {
+  const fields = parseFields(data.fields || process.env.BIRC_MAKE_FIELDS);
+  if (fields.length > 0) {
+    return fields;
+  }
+  if (isExample(data)) {
+    return [{
+      name: 'name',
+      type: 'String',
+      snakeName: 'name',
+      columnLength: DEFAULT_STRING_COLUMN_LENGTH
+    }];
+  }
+  return [];
+}
+
+// 最後防線：prompt 驗證被繞過時（CLI 直呼、程式化呼叫），輸出值也不得
+// 帶 SQL 特殊字元或路徑字元——tableName/columnName 進 Flyway SQL，
+// description 同時進檔名。
+function sanitizeMigrationToken(value) {
+  return String(value || '').replace(/[^a-zA-Z0-9_]/g, '');
+}
+
+function parseMigrationName(name) {
+  const raw = String(name || '').trim();
+  let match = raw.match(/^create_(.+)_table$/i);
+  if (match) {
+    return {
+      kind: 'create',
+      tableName: sanitizeMigrationToken(match[1]),
+      columnName: null,
+      description: sanitizeMigrationToken(raw) || 'migration'
+    };
+  }
+  match = raw.match(/^add_(.+)_to_(.+)_table$/i);
+  if (match) {
+    return {
+      kind: 'add',
+      columnName: sanitizeMigrationToken(match[1]),
+      tableName: sanitizeMigrationToken(match[2]),
+      description: sanitizeMigrationToken(raw) || 'migration'
+    };
+  }
+  match = raw.match(/^remove_(.+)_from_(.+)_table$/i);
+  if (match) {
+    return {
+      kind: 'remove',
+      columnName: sanitizeMigrationToken(match[1]),
+      tableName: sanitizeMigrationToken(match[2]),
+      description: sanitizeMigrationToken(raw) || 'migration'
+    };
+  }
+  const customDescription = sanitizeMigrationToken(raw);
+  return { kind: 'custom', tableName: null, columnName: null, description: customDescription || 'migration' };
+}
+
+function nextMigrationVersion(migrationDir) {
+  if (!fs.existsSync(migrationDir)) {
+    return 1;
+  }
+  const versions = fs
+    .readdirSync(migrationDir)
+    .filter((file) => file.startsWith('V') && file.endsWith('.sql'))
+    .map((file) => {
+      const match = file.match(/^V(\d+)__/);
+      return match ? parseInt(match[1], 10) : 0;
+    });
+  return versions.length ? Math.max(...versions) + 1 : 1;
+}
+
+function migrationTemplate(kind) {
+  if (kind === 'create') return 'templates/migration/create-table.hbs';
+  if (kind === 'add') return 'templates/migration/add-column.hbs';
+  if (kind === 'remove') return 'templates/migration/remove-column.hbs';
+  return 'templates/migration/custom.hbs';
+}
+
+function makeContext(data) {
+  if (data && data.entityName) {
+    data.entityName = toPascalCaseName(data.entityName);
+  }
+  const config = loadProjectConfig();
+  const persistence = resolvePersistence(config);
+  const basePackage = config.basePackage;
+  const srcPath = config.srcPath || 'src/main/java';
+  const root = `${srcPath}/${basePackage.replace(/\./g, '/')}`;
+  const fields = resolveMakeFields(data);
+  const example = isExample(data);
+  const extraImports = fieldImports(fields);
+  const entityImports = extraImports.includes('java.time.LocalDateTime') || !example
+    ? extraImports
+    : extraImports.concat('java.time.LocalDateTime');
+  return {
+    config,
+    persistence,
+    root,
+    gradlePath: config.buildGradlePath || 'build.gradle',
+    templateData: {
+      ...VERSIONS,
+      basePackage,
+      makeFields: fields,
+      extraImports,
+      entityImports,
+      withExample: example,
+      withSoftDelete: includeSoftDelete(data),
+      entityPackage: persistence.entityPackage,
+      daoPackage: persistence.daoPackage
+    }
+  };
+}
+
+function exceptionClassName(name) {
+  const base = toPascalCaseName(name);
+  return /Exception$/i.test(base) ? base.replace(/exception$/i, 'Exception') : `${base}Exception`;
+}
+
+function exceptionSkeletonActions(root, templateData) {
+  return [
+    { type: 'add', path: `${root}/exception/ProjectException.java`, templateFile: 'templates/exception/ProjectException.hbs', data: templateData },
+    { type: 'add', path: `${root}/exception/NotFoundException.java`, templateFile: 'templates/exception/NotFoundException.hbs', data: templateData },
+    { type: 'add', path: `${root}/controller/ExceptionHandleController.java`, templateFile: 'templates/exception/ExceptionHandleController.hbs', data: templateData },
+    { type: 'add', path: `${root}/web/Result.java`, templateFile: 'templates/base/Result.hbs', data: templateData }
+  ];
+}
+
+function serviceSkeletonActions(root, templateData) {
+  return [
+    { type: 'add', path: `${root}/mapper/EntityMapper.java`, templateFile: 'templates/base/EntityMapper.hbs', data: templateData },
+    { type: 'add', path: `${root}/service/BaseService.java`, templateFile: 'templates/base/BaseService.hbs', data: templateData },
+    { type: 'add', path: `${root}/service/impl/BaseServiceImpl.java`, templateFile: 'templates/base/BaseServiceImpl.hbs', data: templateData }
+  ];
+}
+
+function seederSkeletonActions(root, templateData, options) {
+  const skipIfExists = Boolean(options && options.skipIfExists);
+  return [
+    { type: 'add', path: `${root}/seeder/Seeder.java`, templateFile: 'templates/seeder/Seeder.hbs', data: templateData, skipIfExists },
+    { type: 'add', path: `${root}/seeder/SeedRunner.java`, templateFile: 'templates/seeder/SeedRunner.hbs', data: templateData, skipIfExists }
+  ];
+}
+
+function makeEntityActions(data, options) {
+  const { persistence, templateData } = makeContext(data);
+  const skipIfExists = Boolean(options && options.skipIfExists);
+  return [
+    { type: 'add', path: `${persistence.entityRoot}/{{pascalCase entityName}}.java`, templateFile: 'templates/entity.hbs', data: templateData, skipIfExists },
+    { type: 'add', path: `${persistence.daoRoot}/{{pascalCase entityName}}DAO.java`, templateFile: 'templates/dao.hbs', data: templateData, skipIfExists }
+  ];
+}
+
+function makeMapperActions(data, options) {
+  const { root, gradlePath, templateData } = makeContext(data);
+  const skipIfExists = Boolean(options && options.skipIfExists);
+  return [
+    { type: 'add', path: `${root}/dto/{{pascalCase entityName}}CreateRequest.java`, templateFile: 'templates/dto-request.hbs', data: templateData, skipIfExists },
+    { type: 'add', path: `${root}/dto/{{pascalCase entityName}}Response.java`, templateFile: 'templates/dto-response.hbs', data: templateData, skipIfExists },
+    { type: 'add', path: `${root}/mapper/{{pascalCase entityName}}Mapper.java`, templateFile: 'templates/mapper.hbs', data: templateData, skipIfExists },
+    {
+      type: 'appendFragment',
+      path: gradlePath,
+      pattern: /\/\/ birc-generator:dependency-anchor\n/,
+      templateFile: 'templates/mapper-gradle-dep.hbs',
+      data: templateData,
+      marker: 'mapstruct',
+      commentToken: '//',
+      abortOnFail: true
+    }
+  ];
+}
+
+function makeServiceActions(data, options) {
+  const { root, templateData } = makeContext(data);
+  const skipIfExists = Boolean(options && options.skipIfExists);
+  return [
+    { type: 'add', path: `${root}/service/{{pascalCase entityName}}Service.java`, templateFile: 'templates/service.hbs', data: templateData, skipIfExists },
+    { type: 'add', path: `${root}/service/impl/{{pascalCase entityName}}ServiceImpl.java`, templateFile: 'templates/serviceImpl.hbs', data: templateData, skipIfExists }
+  ];
+}
+
+function makeControllerActions(data, options) {
+  const { root, templateData } = makeContext(data);
+  const skipIfExists = Boolean(options && options.skipIfExists);
+  return [
+    {
+      type: 'add',
+      path: `${root}/web/Result.java`,
+      templateFile: 'templates/base/Result.hbs',
+      data: templateData,
+      skipIfExists: true
+    },
+    { type: 'add', path: `${root}/controller/{{pascalCase entityName}}Controller.java`, templateFile: 'templates/controller.hbs', data: templateData, skipIfExists }
+  ];
+}
+
+function makeStackActions(data) {
+  const skipIfExists = skipExistingMakeFiles(data);
+  return appendMakeSqlActions([
+    ...makeEntityActions(data, { skipIfExists }),
+    ...makeMapperActions(data, { skipIfExists }),
+    ...makeServiceActions(data, { skipIfExists }),
+    ...makeControllerActions(data, { skipIfExists })
+  ], data);
+}
+function migrationDir(config) {
+  const resourcesPath = config.resourcesPath || 'src/main/resources';
+  return config.migrationPath || `${resourcesPath}/db/migration`;
+}
+
+function makeMigrationActions(data) {
+  const config = loadProjectConfig();
+  const migrationPath = migrationDir(config);
+  const parsed = parseMigrationName(data.description);
+  const version = data.migrationVersion || nextMigrationVersion(path.join(projectRoot(), migrationPath));
+  const example = isExample(data);
+  const migrationColumns = parsed.kind === 'create'
+    ? resolveCreateTableColumns(data, parsed.tableName, config)
+    : [];
+  return [
+    {
+      type: 'add',
+      path: `${migrationPath}/V${version}__${parsed.description}.sql`,
+      templateFile: migrationTemplate(parsed.kind),
+      data: {
+        description: parsed.description,
+        tableName: parsed.tableName,
+        columnName: parsed.columnName,
+        withExample: example,
+        withSoftDelete: includeSoftDelete(data),
+        migrationColumns
+      }
+    }
+  ];
+}
+
+function makeSeederActions(data) {
+  data.entityName = entityNameForSeeder(data);
+  const { root, templateData } = makeContext(data);
+  const entityName = data.entityName;
+  const seederClass = `${entityName}Seeder`;
+  const tableName = tableNameFromEntity(entityName);
+  const seedFields = resolveSeedFields(data, tableName, loadProjectConfig());
+  return [
+    ...seederSkeletonActions(root, templateData, { skipIfExists: true }),
+    {
+      type: 'add',
+      path: `${root}/seeder/${seederClass}.java`,
+      templateFile: 'templates/seeder.hbs',
+      data: {
+        ...templateData,
+        extraImports: fieldImports(seedFields),
+        seedFields,
+        seederClass,
+        entityName
+      }
+    }
+  ];
+}
+
+function makeModelActions(data) {
+  const actions = makeEntityActions(data, { skipIfExists: true });
+  if (includeMapperWithEntity(data)) {
+    actions.push(...makeMapperActions(data));
+  }
+  appendMakeSqlActions(actions, data);
+  if (includeModelController(data)) {
+    actions.push(...makeControllerActions(data));
+  }
+  return actions;
+}
+
+function appendMakeSqlActions(actions, data) {
+  const config = loadProjectConfig();
+  const migrationPath = migrationDir(config);
+  const version = nextMigrationVersion(path.join(projectRoot(), migrationPath));
+  if (includeModelMigration(data)) {
+    const tableName = tableNameFromEntity(data.entityName);
+    actions.push(
+      ...makeMigrationActions({
+        ...data,
+        description: `create_${tableName}_table`,
+        migrationVersion: version
+      })
+    );
+  }
+  if (includeModelSeed(data)) {
+    actions.push(...makeSeederActions(data));
+  }
+  return actions;
+}
+
+module.exports = {
+  isExample,
+  includeMapperWithEntity,
+  includeModelMigration,
+  includeModelSeed,
+  skipExistingMakeFiles,
+  includeModelController,
+  includeSoftDelete,
+  toSnakeCase,
+  parseMigrationName,
+  validateMigrationName: require('./project').validateMigrationName,
+  makeContext,
+  exceptionClassName,
+  exceptionSkeletonActions,
+  serviceSkeletonActions,
+  seederSkeletonActions,
+  makeEntityActions,
+  makeMapperActions,
+  makeServiceActions,
+  makeControllerActions,
+  makeStackActions,
+  makeModelActions,
+  makeMigrationActions,
+  makeSeederActions,
+  appendMakeSqlActions
+};