nest-hex 0.2.0 → 0.3.2

package/dist/src/cli/generators/adapter.generator.d.ts

@@ -0,0 +1,235 @@
+/**
+* Configuration types for nest-hex CLI
+*/
+interface NestHexConfig {
+	/**
+	* Output directory configuration
+	*/
+	output?: {
+		/**
+		* Directory for generated ports
+		* @default 'src/ports'
+		*/
+		portsDir?: string;
+		/**
+		* Directory for generated adapters
+		* @default 'src/adapters'
+		*/
+		adaptersDir?: string;
+	};
+	/**
+	* Naming conventions
+	*/
+	naming?: {
+		/**
+		* Suffix for port tokens
+		* @default 'PORT'
+		*/
+		portSuffix?: string;
+		/**
+		* Suffix for adapter classes
+		* @default 'Adapter'
+		*/
+		adapterSuffix?: string;
+		/**
+		* File naming case
+		* @default 'kebab'
+		*/
+		fileCase?: "kebab" | "camel" | "pascal";
+	};
+	/**
+	* Code style preferences
+	*/
+	style?: {
+		/**
+		* Indentation style
+		* @default 'tab'
+		*/
+		indent?: "tab" | 2 | 4;
+		/**
+		* Quote style
+		* @default 'single'
+		*/
+		quotes?: "single" | "double";
+		/**
+		* Use semicolons
+		* @default true
+		*/
+		semicolons?: boolean;
+	};
+	/**
+	* Custom template paths
+	*/
+	templates?: {
+		portModule?: string;
+		portToken?: string;
+		portInterface?: string;
+		portService?: string;
+		adapterModule?: string;
+		adapterService?: string;
+		adapterTypes?: string;
+	};
+}
+/**
+* Generator types for CLI
+*/
+interface GeneratorOptions {
+	name: string;
+	outputPath?: string;
+	includeModule?: boolean;
+	includeService?: boolean;
+	registrationType?: "sync" | "async";
+	generateExample?: boolean;
+	dryRun?: boolean;
+}
+interface GeneratorContext extends Record<string, unknown> {
+	original: string;
+	kebab: string;
+	camel: string;
+	pascal: string;
+	snake: string;
+	screamingSnake: string;
+	nameKebab: string;
+	nameCamel: string;
+	namePascal: string;
+	nameSnake: string;
+	nameScreamingSnake: string;
+	portSuffix: string;
+	adapterSuffix: string;
+	fileCase: "kebab" | "camel" | "pascal";
+	indent: "tab" | number;
+	quotes: "single" | "double";
+	semicolons: boolean;
+	includeModule: boolean;
+	includeService: boolean;
+	registrationType: "sync" | "async";
+	generateExample: boolean;
+	coreImportPath: string;
+}
+interface FileToGenerate {
+	path: string;
+	content: string;
+}
+interface GeneratorResult {
+	files: string[];
+	success: boolean;
+	message?: string;
+}
+interface NameVariations {
+	original: string;
+	kebab: string;
+	camel: string;
+	pascal: string;
+	snake: string;
+	screamingSnake: string;
+}
+declare function generateNameVariations(name: string): NameVariations;
+/**
+* Abstract base class for all generators.
+*
+* Provides common functionality like:
+* - Template rendering
+* - File writing
+* - Name transformations
+* - Path resolution
+*/
+declare abstract class BaseGenerator {
+	protected readonly config: NestHexConfig;
+	constructor(config: NestHexConfig);
+	/**
+	* Render a template with the given context.
+	*
+	* @param templatePath - Path to the Handlebars template file
+	* @param context - Template context
+	* @returns Rendered template content
+	*/
+	protected renderTemplate(templatePath: string, context: GeneratorContext): Promise<string>;
+	/**
+	* Write a file to disk.
+	*
+	* @param filePath - Destination file path
+	* @param content - File content
+	* @param dryRun - If true, don't actually write the file
+	* @returns WriteResult indicating success and conflict status
+	*/
+	protected writeFile(filePath: string, content: string, dryRun?: boolean): Promise<import("../utils/file-writer").WriteResult>;
+	/**
+	* Generate all name variations for a given name.
+	*
+	* @param name - Original name
+	* @returns Object with all name case variations
+	*/
+	protected getNameVariations(name: string): ReturnType<typeof generateNameVariations>;
+	/**
+	* Resolve a path relative to the project root.
+	*
+	* @param relativePath - Relative path
+	* @returns Absolute path
+	*/
+	protected resolvePath(relativePath: string): string;
+	/**
+	* Get the template directory for a specific generator type.
+	*
+	* @param type - Generator type (port, adapter, service)
+	* @returns Absolute path to template directory
+	*/
+	protected getTemplateDir(type: "port" | "adapter" | "service" | "examples"): string;
+	/**
+	* Create a template context from generator options.
+	*
+	* @param options - Generator options
+	* @param additionalContext - Additional context to merge
+	* @returns Complete template context
+	*/
+	protected createTemplateContext(options: GeneratorOptions, additionalContext?: Record<string, unknown>): GeneratorContext;
+	/**
+	* Generate files from a list of file specifications.
+	*
+	* @param files - Array of files to generate
+	* @param dryRun - If true, don't actually write files
+	* @returns Array of successfully generated file paths
+	* @throws Error if any files fail to write
+	*/
+	protected generateFiles(files: FileToGenerate[], dryRun?: boolean): Promise<string[]>;
+}
+/**
+* Additional options for adapter generation.
+*/
+interface AdapterGeneratorOptions extends GeneratorOptions {
+	/**
+	* Name of the port this adapter implements.
+	* Used to generate correct imports and token references.
+	*/
+	portName?: string;
+	/**
+	* Path to the port interface file (for imports).
+	* If not provided, assumes standard structure.
+	*/
+	portPath?: string;
+	/**
+	* Port token name (e.g., "OBJECT_STORAGE_PORT").
+	* Used in the @Port decorator.
+	*/
+	portTokenName?: string;
+	/**
+	* Technology or service being adapted (e.g., "AWS S3", "HTTP API").
+	* Used in documentation comments.
+	*/
+	technology?: string;
+}
+/**
+* Generator for creating adapter files.
+*
+* Generates:
+* - Adapter class (extends Adapter base class with @Port decorator)
+* - Service implementation (implements the port interface)
+* - Types file (adapter configuration options)
+* - Index file (barrel exports)
+*/
+declare class AdapterGenerator extends BaseGenerator {
+	/**
+	* Generate all adapter files.
+	*/
+	generate(options: AdapterGeneratorOptions): Promise<GeneratorResult>;
+}
+export { AdapterGeneratorOptions, AdapterGenerator };

package/dist/src/cli/generators/adapter.generator.js

@@ -0,0 +1,377 @@
+var import_node_module = require("node:module");
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
+// src/cli/config/defaults.ts
+var exports_defaults = {};
+__export(exports_defaults, {
+  defaultConfig: () => defaultConfig
+});
+module.exports = __toCommonJS(exports_defaults);
+var defaultConfig = {
+  output: {
+    portsDir: "src/ports",
+    adaptersDir: "src/adapters"
+  },
+  naming: {
+    portSuffix: "PORT",
+    adapterSuffix: "Adapter",
+    fileCase: "kebab"
+  },
+  style: {
+    indent: "tab",
+    quotes: "single",
+    semicolons: true
+  },
+  templates: {}
+};
+
+// src/cli/utils/file-writer.ts
+var exports_file_writer = {};
+__export(exports_file_writer, {
+  writeFile: () => writeFile
+});
+module.exports = __toCommonJS(exports_file_writer);
+async function writeFile(filePath, content, options = {}) {
+  const { force = false, dryRun = false } = options;
+  const file = Bun.file(filePath);
+  const existed = await file.exists();
+  if (existed && !force && !dryRun) {
+    return {
+      success: false,
+      path: filePath,
+      existed: true,
+      written: false,
+      message: "File already exists. Use --force to overwrite."
+    };
+  }
+  if (dryRun) {
+    return {
+      success: true,
+      path: filePath,
+      existed,
+      written: false,
+      message: "Dry run - file not written"
+    };
+  }
+  try {
+    await Bun.write(filePath, content);
+    return {
+      success: true,
+      path: filePath,
+      existed,
+      written: true,
+      message: existed ? "File overwritten" : "File created"
+    };
+  } catch (error) {
+    return {
+      success: false,
+      path: filePath,
+      existed,
+      written: false,
+      message: `Failed to write file: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+
+// src/cli/utils/name-transformer.ts
+var exports_name_transformer = {};
+__export(exports_name_transformer, {
+  toSnakeCase: () => toSnakeCase,
+  toScreamingSnakeCase: () => toScreamingSnakeCase,
+  toPascalCase: () => toPascalCase,
+  toKebabCase: () => toKebabCase,
+  toCamelCase: () => toCamelCase,
+  generateNameVariations: () => generateNameVariations
+});
+module.exports = __toCommonJS(exports_name_transformer);
+function toKebabCase(str) {
+  return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function toCamelCase(str) {
+  return str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^[A-Z]/, (c) => c.toLowerCase());
+}
+function toPascalCase(str) {
+  const camel = toCamelCase(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function toSnakeCase(str) {
+  return str.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+}
+function toScreamingSnakeCase(str) {
+  return toSnakeCase(str).toUpperCase();
+}
+function generateNameVariations(name) {
+  return {
+    original: name,
+    kebab: toKebabCase(name),
+    camel: toCamelCase(name),
+    pascal: toPascalCase(name),
+    snake: toSnakeCase(name),
+    screamingSnake: toScreamingSnakeCase(name)
+  };
+}
+
+// src/cli/utils/path-resolver.ts
+var exports_path_resolver = {};
+__export(exports_path_resolver, {
+  resolvePath: () => resolvePath,
+  joinPaths: () => joinPaths,
+  getRelativePath: () => getRelativePath,
+  getImportPath: () => getImportPath
+});
+module.exports = __toCommonJS(exports_path_resolver);
+var import_node_path = require("node:path");
+function resolvePath(...segments) {
+  return import_node_path.resolve(...segments);
+}
+function joinPaths(...segments) {
+  return import_node_path.join(...segments);
+}
+function getRelativePath(from, to) {
+  const relativePath = import_node_path.relative(from, to);
+  return relativePath.replace(/\\/g, "/");
+}
+function getImportPath(from, to) {
+  const relPath = getRelativePath(import_node_path.dirname(from), to);
+  const withoutExt = relPath.replace(/\.(ts|js)$/, "");
+  return withoutExt.startsWith(".") ? withoutExt : `./${withoutExt}`;
+}
+
+// src/cli/utils/template-renderer.ts
+var exports_template_renderer = {};
+__export(exports_template_renderer, {
+  renderTemplateString: () => renderTemplateString,
+  renderTemplate: () => renderTemplate
+});
+module.exports = __toCommonJS(exports_template_renderer);
+var import_handlebars = __toESM(require("handlebars"));
+async function renderTemplate(templatePath, context) {
+  try {
+    const file = Bun.file(templatePath);
+    if (!await file.exists()) {
+      throw new Error(`Template file not found: ${templatePath}
+` + "Please ensure the template exists or report this as a bug.");
+    }
+    const templateSource = await file.text();
+    try {
+      const template = import_handlebars.default.compile(templateSource);
+      return template(context);
+    } catch (compileError) {
+      throw new Error(`Failed to compile template ${templatePath}: ` + `${compileError instanceof Error ? compileError.message : String(compileError)}
+` + "This may indicate invalid Handlebars syntax in the template.");
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Template file not found")) {
+      throw error;
+    }
+    if (error instanceof Error && error.message.includes("Failed to compile template")) {
+      throw error;
+    }
+    throw new Error(`Failed to read template ${templatePath}: ` + `${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function renderTemplateString(templateString, context) {
+  try {
+    const template = import_handlebars.default.compile(templateString);
+    return template(context);
+  } catch (error) {
+    throw new Error("Failed to compile template string: " + `${error instanceof Error ? error.message : String(error)}
+` + "This may indicate invalid Handlebars syntax.");
+  }
+}
+
+// src/cli/generators/base.generator.ts
+var exports_base_generator = {};
+__export(exports_base_generator, {
+  BaseGenerator: () => BaseGenerator
+});
+module.exports = __toCommonJS(exports_base_generator);
+var import_node_path2 = require("node:path");
+var __dirname = "/home/runner/work/nest-hex/nest-hex/src/cli/generators";
+
+class BaseGenerator {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async renderTemplate(templatePath, context) {
+    return renderTemplate(templatePath, context);
+  }
+  async writeFile(filePath, content, dryRun = false) {
+    return writeFile(filePath, content, {
+      dryRun,
+      force: false
+    });
+  }
+  getNameVariations(name) {
+    return generateNameVariations(name);
+  }
+  resolvePath(relativePath) {
+    return resolvePath(relativePath);
+  }
+  getTemplateDir(type) {
+    const templatesRoot = import_node_path2.join(__dirname, "..", "templates");
+    return import_node_path2.join(templatesRoot, type);
+  }
+  createTemplateContext(options, additionalContext = {}) {
+    const names = this.getNameVariations(options.name);
+    return {
+      ...names,
+      nameKebab: names.kebab,
+      nameCamel: names.camel,
+      namePascal: names.pascal,
+      nameSnake: names.snake,
+      nameScreamingSnake: names.screamingSnake,
+      portSuffix: this.config.naming?.portSuffix ?? defaultConfig.naming.portSuffix,
+      adapterSuffix: this.config.naming?.adapterSuffix ?? defaultConfig.naming.adapterSuffix,
+      fileCase: this.config.naming?.fileCase ?? defaultConfig.naming.fileCase,
+      indent: this.config.style?.indent ?? defaultConfig.style.indent,
+      quotes: this.config.style?.quotes ?? defaultConfig.style.quotes,
+      semicolons: this.config.style?.semicolons ?? defaultConfig.style.semicolons,
+      includeModule: options.includeModule ?? true,
+      includeService: options.includeService ?? true,
+      registrationType: options.registrationType ?? "sync",
+      generateExample: options.generateExample ?? false,
+      coreImportPath: "nest-hex",
+      ...additionalContext
+    };
+  }
+  async generateFiles(files, dryRun = false) {
+    const generatedFiles = [];
+    const failures = [];
+    for (const file of files) {
+      const result = await this.writeFile(file.path, file.content, dryRun);
+      if (result.success) {
+        generatedFiles.push(file.path);
+      } else {
+        failures.push({
+          path: file.path,
+          error: result.message || "Unknown error"
+        });
+        console.error(`Failed to write ${file.path}: ${result.message}`);
+      }
+    }
+    if (failures.length > 0) {
+      const errorMsg = `Failed to generate ${failures.length} file(s):
+` + failures.map((f) => `  - ${f.path}: ${f.error}`).join(`
+`);
+      throw new Error(errorMsg);
+    }
+    return generatedFiles;
+  }
+}
+
+// src/cli/generators/adapter.generator.ts
+var exports_adapter_generator = {};
+__export(exports_adapter_generator, {
+  AdapterGenerator: () => AdapterGenerator
+});
+module.exports = __toCommonJS(exports_adapter_generator);
+var import_node_path3 = require("node:path");
+class AdapterGenerator extends BaseGenerator {
+  async generate(options) {
+    const portNameVariations = options.portName ? this.getNameVariations(options.portName) : undefined;
+    let portImportPath;
+    if (portNameVariations && !options.portPath) {
+      const portsDir = this.config.output?.portsDir || "ports";
+      const adaptersDir = this.config.output?.adaptersDir || "adapters";
+      const portsDirName = import_node_path3.basename(portsDir);
+      const _adaptersDirName = import_node_path3.basename(adaptersDir);
+      portImportPath = `../../${portsDirName}/${portNameVariations.kebab}`;
+    }
+    const context = this.createTemplateContext(options, {
+      portName: options.portName,
+      portPath: options.portPath,
+      technology: options.technology,
+      ...portNameVariations ? {
+        portNameKebab: portNameVariations.kebab,
+        portNamePascal: portNameVariations.pascal,
+        portNameCamel: portNameVariations.camel,
+        portNameScreamingSnake: portNameVariations.screamingSnake,
+        portTokenName: options.portTokenName || `${portNameVariations.screamingSnake}_${this.config.naming?.portSuffix || "PORT"}`,
+        portInterfaceName: `${portNameVariations.pascal}Port`,
+        portImportPath: options.portPath || portImportPath
+      } : {}
+    });
+    const templateDir = this.getTemplateDir("adapter");
+    const outputDir = options.outputPath || this.resolvePath(this.config.output?.adaptersDir || "src/adapters");
+    const adapterDir = import_node_path3.join(outputDir, context.nameKebab);
+    const files = [];
+    const adapterContent = await this.renderTemplate(import_node_path3.join(templateDir, "adapter.hbs"), context);
+    files.push({
+      path: import_node_path3.join(adapterDir, `${context.nameKebab}.adapter.ts`),
+      content: adapterContent
+    });
+    const serviceContent = await this.renderTemplate(import_node_path3.join(templateDir, "service.hbs"), context);
+    files.push({
+      path: import_node_path3.join(adapterDir, `${context.nameKebab}.service.ts`),
+      content: serviceContent
+    });
+    const typesContent = await this.renderTemplate(import_node_path3.join(templateDir, "types.hbs"), context);
+    files.push({
+      path: import_node_path3.join(adapterDir, `${context.nameKebab}.types.ts`),
+      content: typesContent
+    });
+    const indexContent = await this.renderTemplate(import_node_path3.join(templateDir, "index.hbs"), context);
+    files.push({
+      path: import_node_path3.join(adapterDir, "index.ts"),
+      content: indexContent
+    });
+    const generatedFiles = await this.generateFiles(files, options.dryRun);
+    return {
+      success: true,
+      files: generatedFiles,
+      message: `Successfully generated adapter files for ${context.namePascal}`
+    };
+  }
+}