nest-hex 0.2.0 → 0.2.2

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

@@ -0,0 +1,340 @@
+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 = "C:\\Users\\liorv\\OneDrive\\Desktop\\Projects\\Personal\\nestjs-adapter\\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/service.generator.ts
+var exports_service_generator = {};
+__export(exports_service_generator, {
+  ServiceGenerator: () => ServiceGenerator
+});
+module.exports = __toCommonJS(exports_service_generator);
+var import_node_path3 = require("node:path");
+class ServiceGenerator extends BaseGenerator {
+  async generate(options) {
+    const context = this.createTemplateContext(options);
+    const templateDir = this.getTemplateDir("service");
+    const outputDir = options.outputPath || this.resolvePath(this.config.output?.portsDir || "src/services");
+    const serviceDir = import_node_path3.join(outputDir, context.nameKebab);
+    const files = [];
+    const serviceContent = await this.renderTemplate(import_node_path3.join(templateDir, "injectable-service.hbs"), context);
+    files.push({
+      path: import_node_path3.join(serviceDir, `${context.nameKebab}.service.ts`),
+      content: serviceContent
+    });
+    const generatedFiles = await this.generateFiles(files, options.dryRun);
+    return {
+      success: true,
+      files: generatedFiles,
+      message: `Successfully generated ${generatedFiles.length} service file${generatedFiles.length !== 1 ? "s" : ""}`
+    };
+  }
+}

package/dist/src/cli/index.d.ts

@@ -0,0 +1,74 @@
+/**
+* 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;
+	};
+}
+declare function defineConfig(config: NestHexConfig): NestHexConfig;
+export { defineConfig, NestHexConfig };

package/dist/src/cli/index.js

@@ -0,0 +1,69 @@
+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/define-config.ts
+var exports_define_config = {};
+__export(exports_define_config, {
+  defineConfig: () => defineConfig
+});
+module.exports = __toCommonJS(exports_define_config);
+function defineConfig(config) {
+  return config;
+}
+
+// src/cli/index.ts
+var exports_cli = {};
+__export(exports_cli, {
+  defineConfig: () => defineConfig
+});
+module.exports = __toCommonJS(exports_cli);

package/dist/src/cli/types/config.types.d.ts

@@ -0,0 +1,73 @@
+/**
+* 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;
+	};
+}
+export { NestHexConfig };

package/dist/src/cli/types/config.types.js

@@ -0,0 +1,56 @@
+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/types/config.types.ts
+var exports_config_types = {};
+module.exports = __toCommonJS(exports_config_types);

package/dist/src/cli/types/generator.types.d.ts

@@ -0,0 +1,46 @@
+/**
+* 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;
+}
+export { GeneratorResult, GeneratorOptions, GeneratorContext, FileToGenerate };