lombok-typescript 0.1.0

package/dist/cli/index.cjs

@@ -0,0 +1,585 @@
+#!/usr/bin/env node
+'use strict';
+
+var cac = require('cac');
+var fs = require('fs');
+var path = require('path');
+var tsMorph = require('ts-morph');
+var bundleRequire = require('bundle-require');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// src/cli/index.ts
+async function runClean(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const paths = opts.paths ?? [".lombok", "dist", "coverage"];
+  const log = opts.log ?? ((msg) => console.info(msg));
+  const removed = [];
+  const skipped = [];
+  for (const rel of paths) {
+    const abs = path.resolve(cwd, rel);
+    if (fs.existsSync(abs)) {
+      fs.rmSync(abs, { recursive: true, force: true });
+      removed.push(rel);
+      log(`Removed ${rel}/`);
+    } else {
+      skipped.push(rel);
+    }
+  }
+  if (removed.length === 0) {
+    log("Nothing to clean.");
+  }
+  return { removed, skipped };
+}
+function analyzeFile(sourceFile) {
+  return sourceFile.getClasses().map((cls) => analyzeClassDeclaration(cls));
+}
+function analyzeClassDeclaration(cls) {
+  const name = cls.getName() ?? "<anonymous>";
+  return {
+    name,
+    decorators: cls.getDecorators().map(toDecoratorInfo),
+    fields: cls.getProperties().map(toFieldInfo),
+    methods: cls.getMethods().map(toMethodInfo)
+  };
+}
+function toDecoratorInfo(decorator) {
+  return {
+    name: decorator.getName(),
+    arguments: decorator.getArguments().map((arg) => arg.getText())
+  };
+}
+function toFieldInfo(prop) {
+  const initializer = prop.getInitializer();
+  return {
+    name: prop.getName(),
+    type: prop.getType().getText(prop),
+    isOptional: prop.hasQuestionToken(),
+    isReadonly: prop.isReadonly(),
+    hasDefault: initializer !== void 0,
+    defaultValue: initializer?.getText(),
+    decorators: prop.getDecorators().map(toDecoratorInfo)
+  };
+}
+function toMethodInfo(method) {
+  return {
+    name: method.getName(),
+    returnType: method.getReturnType().getText(method),
+    parameters: method.getParameters().map(toParameterInfo),
+    decorators: method.getDecorators().map(toDecoratorInfo),
+    isAsync: method.isAsync(),
+    isStatic: method.isStatic()
+  };
+}
+function toParameterInfo(param) {
+  return {
+    name: param.getName(),
+    type: param.getType().getText(param),
+    isOptional: param.hasQuestionToken() || param.hasInitializer() || param.getDotDotDotToken()?.getKind() === tsMorph.SyntaxKind.DotDotDotToken,
+    decorators: param.getDecorators().map(toDecoratorInfo)
+  };
+}
+function toImportPath(sourcePath, fromDir) {
+  let rel = path.relative(fromDir, sourcePath).replace(/\\/g, "/");
+  if (!rel.startsWith(".")) rel = "./" + rel;
+  return rel.replace(/\.tsx?$/u, ".js");
+}
+function hasCodegenClassDecorator(info) {
+  return hasClassDecorator(info, "Builder") || hasClassDecorator(info, "Data") || hasClassDecorator(info, "ToString");
+}
+function hasClassDecorator(info, name) {
+  return info.decorators.some((d) => d.name === name);
+}
+function fieldExcludesToString(field) {
+  return field.decorators.some(
+    (d) => d.name === "ToStringExclude" || d.name === "ToString.Exclude"
+  );
+}
+function visibleFields(info) {
+  if (hasClassDecorator(info, "ToString")) {
+    return info.fields.filter((f) => !fieldExcludesToString(f));
+  }
+  return info.fields;
+}
+function builderClassName(className) {
+  return `${className}Builder`;
+}
+
+// src/codegen/emitters/builder.ts
+function emitBuilderClass(info) {
+  if (!hasClassDecorator(info, "Builder")) {
+    return "";
+  }
+  const builderName = builderClassName(info.name);
+  const fieldLines = info.fields.map((f) => {
+    if (f.isOptional) {
+      return `  private _${f.name}?: ${f.type};`;
+    }
+    return `  private _${f.name}!: ${f.type};`;
+  });
+  const setterMethods = info.fields.map(
+    (f) => `
+  ${f.name}(value: ${f.type}): ${builderName} {
+    this._${f.name} = value;
+    return this;
+  }`.trim()
+  );
+  return `
+export class ${builderName} {
+${fieldLines.join("\n")}
+
+  static builder(): ${builderName} {
+    return new ${builderName}();
+  }
+
+${setterMethods.join("\n\n")}
+
+  build(): ${info.name} {
+    const instance = new ${info.name}();
+${info.fields.map((f) => `    instance.${f.name} = this._${f.name}${f.isOptional ? "" : "!"};`).join("\n")}
+    return instance;
+  }
+}`.trim();
+}
+function emitDeclarationShim(sourcePath, companionOutputPath, classes) {
+  const relSource = toImportPath(sourcePath, path.dirname(companionOutputPath));
+  const lines = [
+    "// Auto-generated type augmentation by lombok-typescript.",
+    "// Do not edit. Regenerate via `lombok-ts generate`.",
+    "",
+    "export {};",
+    "",
+    `declare module '${relSource}' {`
+  ];
+  for (const info of classes) {
+    if (hasClassDecorator(info, "Builder")) {
+      const builderName = builderClassName(info.name);
+      lines.push(`  export class ${builderName} {`);
+      lines.push(`    static builder(): ${builderName};`);
+      for (const f of info.fields) {
+        lines.push(`    ${f.name}(value: ${f.type}): ${builderName};`);
+      }
+      lines.push(`    build(): ${info.name};`);
+      lines.push("  }");
+      lines.push("");
+    }
+    if (hasClassDecorator(info, "Builder")) {
+      const builderName = builderClassName(info.name);
+      lines.push(`  export class ${info.name} {`);
+      lines.push(`    static builder(): ${builderName};`);
+      lines.push("  }");
+      lines.push("");
+    }
+    const augments = [];
+    if (hasClassDecorator(info, "Data")) {
+      for (const f of info.fields) {
+        const g = `get${f.name.charAt(0).toUpperCase()}${f.name.slice(1)}`;
+        augments.push(`    ${g}(): ${f.type};`);
+        if (!f.isReadonly) {
+          const s = `set${f.name.charAt(0).toUpperCase()}${f.name.slice(1)}`;
+          augments.push(`    ${s}(value: ${f.type}): void;`);
+        }
+      }
+      augments.push(`    equals(other: ${info.name} | null | undefined): boolean;`);
+      augments.push(`    toString(): string;`);
+    } else if (hasClassDecorator(info, "ToString")) {
+      augments.push("    toString(): string;");
+    }
+    if (augments.length > 0) {
+      lines.push(`  interface ${info.name} {`);
+      lines.push(...augments);
+      lines.push("  }");
+    }
+  }
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/codegen/emitters/index.ts
+function emitImports(classes, importPath) {
+  const names = classes.filter(hasCodegenClassDecorator).map((c) => c.name);
+  if (names.length === 0) return "";
+  return `import { ${names.join(", ")} } from '${importPath}';
+
+`;
+}
+function emitToStringFn(info) {
+  if (!hasClassDecorator(info, "ToString") && !hasClassDecorator(info, "Data")) return "";
+  const fields = visibleFields(info);
+  const parts = fields.map((f) => `${f.name}=\${String(this.${f.name})}`).join(", ");
+  return `
+function ${info.name}_toString(this: ${info.name}): string {
+  return \`${info.name}(${parts})\`;
+}`.trim();
+}
+function emitApplyMixin(info) {
+  const assignments = [];
+  if (hasClassDecorator(info, "Data")) {
+    for (const f of info.fields) {
+      const g = `get${f.name.charAt(0).toUpperCase()}${f.name.slice(1)}`;
+      assignments.push(`prototype.${g} = ${info.name}_${g};`);
+      if (!f.isReadonly) {
+        const s = `set${f.name.charAt(0).toUpperCase()}${f.name.slice(1)}`;
+        assignments.push(`prototype.${s} = ${info.name}_${s};`);
+      }
+    }
+    assignments.push(`prototype.equals = ${info.name}_equals;`);
+    assignments.push(`prototype.toString = ${info.name}_toString;`);
+  } else if (hasClassDecorator(info, "ToString")) {
+    assignments.push(`prototype.toString = ${info.name}_toString;`);
+  }
+  if (hasClassDecorator(info, "Builder")) {
+    const bName = builderClassName(info.name);
+    assignments.push(
+      `(ctor as typeof ${info.name} & { builder(): ${bName} }).builder = ${info.name}_builder;`
+    );
+  }
+  if (assignments.length === 0) return "";
+  return `
+export function apply${info.name}Generated(ctor: typeof ${info.name}): void {
+  const prototype = ctor.prototype as unknown as Record<string, unknown>;
+  ${assignments.join("\n  ")}
+}`.trim();
+}
+function emitDataFns(info) {
+  if (!hasClassDecorator(info, "Data")) return "";
+  const fns = [];
+  for (const f of info.fields) {
+    const g = `get${f.name.charAt(0).toUpperCase()}${f.name.slice(1)}`;
+    fns.push(
+      `
+function ${info.name}_${g}(this: ${info.name}): ${f.type} {
+  return this.${f.name};
+}`.trim()
+    );
+    if (!f.isReadonly) {
+      const s = `set${f.name.charAt(0).toUpperCase()}${f.name.slice(1)}`;
+      fns.push(
+        `
+function ${info.name}_${s}(this: ${info.name}, value: ${f.type}): void {
+  this.${f.name} = value;
+}`.trim()
+      );
+    }
+  }
+  const equalsBody = info.fields.map((f) => `this.${f.name} === other.${f.name}`).join(" &&\n    ");
+  fns.push(
+    `
+function ${info.name}_equals(this: ${info.name}, other: ${info.name} | null | undefined): boolean {
+  if (other === null || other === undefined) return false;
+  if (!(other instanceof (this.constructor as typeof ${info.name}))) return false;
+  return ${equalsBody || "true"};
+}`.trim()
+  );
+  fns.push(emitToStringFn(info));
+  return fns.filter(Boolean).join("\n\n");
+}
+function emitBuilderFn(info) {
+  if (!hasClassDecorator(info, "Builder")) return "";
+  const bName = builderClassName(info.name);
+  return `
+function ${info.name}_builder(): ${bName} {
+  return ${bName}.builder();
+}`.trim();
+}
+function emitCompanionFile(sourcePath, companionOutputPath, classes, cwd) {
+  const header = [
+    "// Auto-generated by lombok-typescript.",
+    "// Source: " + path.relative(cwd, sourcePath).replace(/\\/g, "/"),
+    "// Do not edit. Regenerate via `lombok-ts generate`.",
+    ""
+  ].join("\n");
+  const importPath = toImportPath(sourcePath, path.dirname(companionOutputPath));
+  const blocks = [];
+  for (const info of classes) {
+    const builder = emitBuilderClass(info);
+    if (builder) blocks.push(builder);
+    if (hasClassDecorator(info, "Data")) {
+      blocks.push(emitDataFns(info));
+    } else {
+      const ts2 = emitToStringFn(info);
+      if (ts2) blocks.push(ts2);
+    }
+    const builderFn = emitBuilderFn(info);
+    if (builderFn) blocks.push(builderFn);
+    const apply = emitApplyMixin(info);
+    if (apply) blocks.push(apply);
+  }
+  const applyAll = classes.filter((c) => emitApplyMixin(c)).length > 0 ? `
+
+export function applyAllGenerated(handlers: {
+${classes.filter((c) => emitApplyMixin(c)).map((c) => `  ${c.name}: typeof ${c.name};`).join("\n")}
+}): void {
+${classes.filter((c) => emitApplyMixin(c)).map((c) => `  apply${c.name}Generated(handlers.${c.name});`).join("\n")}
+}
+` : "\nexport {};\n";
+  const imports = emitImports(classes, importPath);
+  const ts = header + imports + blocks.join("\n\n") + applyAll;
+  const dts = emitDeclarationShim(sourcePath, companionOutputPath, classes);
+  return { ts, dts };
+}
+
+// src/codegen/generator.ts
+var DEFAULT_OPTIONS = {
+  outputDir: ".lombok",
+  watch: false,
+  include: ["src/**/*.ts"],
+  exclude: ["node_modules", "**/*.test.ts", "**/*.spec.ts", "dist", ".lombok"],
+  tsConfigPath: "tsconfig.json"
+};
+var CodeGenerator = class {
+  options;
+  constructor(options = {}) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  /**
+   * Run codegen against all matching source files.
+   *
+   * Uses the project's `tsConfigPath` if it exists, otherwise an in-memory
+   * project that processes the configured globs. For each file with at least
+   * one class, writes a companion stub to `<outputDir>/<rel-path>.lombok.ts`.
+   */
+  async generate() {
+    const project = this.createProject();
+    const sourceFiles = project.getSourceFiles();
+    const generated = [];
+    for (const sourceFile of sourceFiles) {
+      if (!this.shouldProcess(sourceFile.getFilePath())) continue;
+      const classes = analyzeFile(sourceFile);
+      if (classes.length === 0) continue;
+      const sourcePath = sourceFile.getFilePath();
+      const outputPath = this.computeOutputPath(sourcePath);
+      const { ts, dts } = emitCompanionFile(sourcePath, outputPath, classes, process.cwd());
+      const content = ts;
+      this.writeOutput(outputPath, content);
+      this.writeOutput(outputPath.replace(/\.lombok\.ts$/u, ".lombok.d.ts"), dts);
+      generated.push({
+        sourcePath,
+        outputPath,
+        content,
+        processedClasses: classes.map((c) => c.name)
+      });
+    }
+    return generated;
+  }
+  /** Generate code for a single source file path. */
+  async generateForFile(filePath) {
+    const project = new tsMorph.Project({
+      useInMemoryFileSystem: false,
+      compilerOptions: { allowJs: false }
+    });
+    const sourceFile = project.addSourceFileAtPath(filePath);
+    const classes = analyzeFile(sourceFile);
+    if (classes.length === 0) return null;
+    const outputPath = this.computeOutputPath(filePath);
+    const { ts, dts } = emitCompanionFile(filePath, outputPath, classes, process.cwd());
+    const content = ts;
+    this.writeOutput(outputPath, content);
+    this.writeOutput(outputPath.replace(/\.lombok\.ts$/u, ".lombok.d.ts"), dts);
+    return {
+      sourcePath: filePath,
+      outputPath,
+      content,
+      processedClasses: classes.map((c) => c.name)
+    };
+  }
+  /** Watch mode is not implemented yet. Re-run `lombok-ts generate` for now. */
+  async watch() {
+    throw new Error(
+      "Watch mode is not implemented yet. Re-run `lombok-ts generate` after changes."
+    );
+  }
+  // Internal helpers
+  createProject() {
+    const tsConfig = path.resolve(this.options.tsConfigPath);
+    if (fs.existsSync(tsConfig)) {
+      return new tsMorph.Project({ tsConfigFilePath: tsConfig });
+    }
+    const project = new tsMorph.Project({
+      compilerOptions: {
+        allowJs: false,
+        target: 99
+        /* ESNext */
+      }
+    });
+    if (this.options.include.length > 0) {
+      project.addSourceFilesAtPaths(this.options.include);
+    }
+    return project;
+  }
+  shouldProcess(filePath) {
+    const abs = filePath.replace(/\\/g, "/");
+    const rel = path.relative(process.cwd(), filePath).replace(/\\/g, "/");
+    const excluded = this.options.exclude.some(
+      (pat) => matchesGlob(rel, pat) || matchesGlob(abs, pat)
+    );
+    if (excluded) return false;
+    if (this.options.include.length === 0) return true;
+    return this.options.include.some((pat) => matchesGlob(rel, pat) || matchesGlob(abs, pat));
+  }
+  computeOutputPath(sourcePath) {
+    const cwd = process.cwd();
+    const rel = path.relative(cwd, sourcePath);
+    const base = rel.replace(/\.ts$/u, ".lombok.ts");
+    return path.resolve(cwd, this.options.outputDir, base);
+  }
+  renderCompanion(_sourcePath, _classes) {
+    return "export {};\n";
+  }
+  writeOutput(outputPath, content) {
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, content, "utf8");
+  }
+};
+function matchesGlob(filePath, pattern) {
+  const norm = filePath.replace(/\\/g, "/");
+  const regex = new RegExp(
+    "^" + pattern.replace(/[.+^$()|[\]{}]/g, "\\$&").replace(/\*\*\//g, "__GLOBSTAR_SLASH__").replace(/\*\*/g, "__GLOBSTAR__").replace(/\*/g, "[^/]*").replace(/__GLOBSTAR_SLASH__/g, "(?:.*/)?").replace(/__GLOBSTAR__/g, ".*") + "$",
+    "u"
+  );
+  return regex.test(norm);
+}
+var CONFIG_FILE_NAMES = [
+  "lombok.config.ts",
+  "lombok.config.mts",
+  "lombok.config.cts",
+  "lombok.config.js",
+  "lombok.config.mjs",
+  "lombok.config.cjs"
+];
+function findConfigFile(searchDir = process.cwd()) {
+  for (const name of CONFIG_FILE_NAMES) {
+    const candidate = path.resolve(searchDir, name);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return void 0;
+}
+async function loadConfig(searchDir = process.cwd()) {
+  const filepath = findConfigFile(searchDir);
+  if (!filepath) return void 0;
+  return loadConfigFromFile(filepath);
+}
+async function loadConfigFromFile(filepath) {
+  if (!fs.existsSync(filepath)) {
+    throw new Error(`Config file not found: ${filepath}`);
+  }
+  const { mod } = await bundleRequire.bundleRequire({ filepath });
+  const hasDefault = mod !== null && typeof mod === "object" && "default" in mod;
+  const candidate = hasDefault ? mod.default : mod;
+  if (candidate === null || candidate === void 0 || typeof candidate !== "object") {
+    throw new Error(
+      `Config file ${filepath} did not export a valid config object. Make sure it has a default export of \`defineConfig({...})\`.`
+    );
+  }
+  return { filepath, config: candidate };
+}
+
+// src/cli/commands/generate.ts
+async function runGenerate(opts = {}) {
+  const log = opts.log ?? ((msg) => console.info(msg));
+  const loaded = await loadConfig(opts.cwd);
+  const codegenOpts = {
+    ...loaded?.config.codegen ?? {},
+    ...opts.overrides
+  };
+  if (loaded) {
+    log(`Loaded config from ${loaded.filepath}`);
+  } else {
+    log("No lombok.config.* file found, using defaults.");
+  }
+  const generator = new CodeGenerator(codegenOpts);
+  const generated = await generator.generate();
+  log(
+    `Generated ${generated.length} companion file${generated.length === 1 ? "" : "s"} under ${generator.options.outputDir}/`
+  );
+  for (const entry of generated) {
+    log(`  - ${entry.outputPath} (${entry.processedClasses.join(", ")})`);
+  }
+  return {
+    generatedCount: generated.length,
+    outputDir: generator.options.outputDir
+  };
+}
+var TEMPLATE = `import { defineConfig } from 'lombok-typescript';
+
+export default defineConfig({
+  // Decorator backend: 'legacy' (experimentalDecorators), 'stage3' (ECMAScript),
+  // or 'auto' to pick based on your tsconfig.
+  backend: 'auto',
+
+  // Codegen options used by \`lombok-ts generate\`.
+  codegen: {
+    outputDir: '.lombok',
+    include: ['src/**/*.ts'],
+    exclude: ['node_modules', '**/*.test.ts', '**/*.spec.ts'],
+    tsConfigPath: 'tsconfig.json',
+    watch: false,
+  },
+});
+`;
+async function runInit(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const fileName = opts.fileName ?? "lombok.config.ts";
+  const filepath = path.resolve(cwd, fileName);
+  const log = opts.log ?? ((msg) => console.info(msg));
+  if (fs.existsSync(filepath) && !opts.force) {
+    log(`${fileName} already exists. Use --force to overwrite.`);
+    return { filepath, created: false };
+  }
+  fs.writeFileSync(filepath, TEMPLATE, "utf8");
+  log(`Created ${fileName}`);
+  return { filepath, created: true };
+}
+
+// src/cli/commands/watch.ts
+async function runWatch(opts = {}) {
+  const log = opts.log ?? ((msg) => console.info(msg));
+  log("Watch mode is not implemented yet (Phase 2).");
+  log("Re-run `lombok-ts generate` after changes.");
+}
+
+// src/cli/index.ts
+var CLI_NAME = "lombok-ts";
+var CLI_VERSION = "0.1.0-pre";
+function buildCli() {
+  const cli = cac.cac(CLI_NAME);
+  cli.command("generate", "Run codegen once against the configured source files").alias("gen").option("--output-dir <dir>", "Override codegen output directory").option("--ts-config <path>", "Path to tsconfig.json (default: tsconfig.json)").action(async (options) => {
+    await runGenerate({
+      overrides: {
+        ...options.outputDir ? { outputDir: options.outputDir } : {},
+        ...options.tsConfig ? { tsConfigPath: options.tsConfig } : {}
+      }
+    });
+  });
+  cli.command("watch", "Watch source files and regenerate on change (Phase 2)").action(async () => {
+    await runWatch();
+  });
+  cli.command("init", "Create a starter lombok.config.ts in the current directory").option("--force", "Overwrite an existing config file").action(async (options) => {
+    await runInit({ force: options.force });
+  });
+  cli.command("clean", "Remove generated files and build artifacts").action(async () => {
+    await runClean();
+  });
+  cli.help();
+  cli.version(CLI_VERSION);
+  return cli;
+}
+async function runCli(argv = process.argv) {
+  const cli = buildCli();
+  cli.parse(argv, { run: false });
+  await cli.runMatchedCommand();
+}
+var isMain = typeof process !== "undefined" && typeof (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)) === "string" && process.argv[1] !== void 0 && (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)).endsWith(process.argv[1].split("/").pop() ?? "");
+if (isMain) {
+  runCli().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}
+
+exports.CLI_NAME = CLI_NAME;
+exports.CLI_VERSION = CLI_VERSION;
+exports.buildCli = buildCli;
+exports.runCli = runCli;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map