@abhinav2-3/core 0.1.0

package/src/installers/base.ts

@@ -0,0 +1,31 @@
+import execa from 'execa';
+import chalk from 'chalk';
+
+export interface Installer {
+  install(projectPath: string): Promise<void>;
+  getName(): string;
+}
+
+export abstract class BaseInstaller implements Installer {
+  abstract getName(): string;
+  abstract getInstallCommand(): { command: string; args: string[] };
+
+  async install(projectPath: string): Promise<void> {
+    const { command, args } = this.getInstallCommand();
+
+    console.log(
+      chalk.cyan(`\n📦 Installing dependencies using ${this.getName()}...`),
+    );
+
+    try {
+      await execa(command, args, {
+        cwd: projectPath,
+        stdio: 'inherit',
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to install dependencies using ${this.getName()}: ${error}`,
+      );
+    }
+  }
+}

package/src/installers/implementations.ts

@@ -0,0 +1,28 @@
+import { BaseInstaller } from './base';
+
+export class NpmInstaller extends BaseInstaller {
+  getName(): string {
+    return 'npm';
+  }
+  getInstallCommand() {
+    return { command: 'npm', args: ['install'] };
+  }
+}
+
+export class PnpmInstaller extends BaseInstaller {
+  getName(): string {
+    return 'pnpm';
+  }
+  getInstallCommand() {
+    return { command: 'pnpm', args: ['install'] };
+  }
+}
+
+export class YarnInstaller extends BaseInstaller {
+  getName(): string {
+    return 'yarn';
+  }
+  getInstallCommand() {
+    return { command: 'yarn', args: ['install'] };
+  }
+}

package/src/installers/index.ts

@@ -0,0 +1,16 @@
+import { Installer } from './base';
+import { NpmInstaller, PnpmInstaller, YarnInstaller } from './implementations';
+import { PackageManager } from '../types';
+
+export const resolveInstaller = (packageManager: PackageManager): Installer => {
+  switch (packageManager) {
+    case 'npm':
+      return new NpmInstaller();
+    case 'pnpm':
+      return new PnpmInstaller();
+    case 'yarn':
+      return new YarnInstaller();
+    default:
+      return new NpmInstaller();
+  }
+};

package/src/resolvers/templateResolver.ts

@@ -0,0 +1,26 @@
+import path from 'path';
+import { GeneratorConfig } from '../types';
+import { exists } from '../filesystem';
+import { getTemplatesPath } from '../constants/paths';
+
+export const resolveTemplatePath = async (
+  config: GeneratorConfig,
+  assetsRoot?: string,
+): Promise<string> => {
+  const templateBaseDir = assetsRoot
+    ? path.join(assetsRoot, 'templates')
+    : getTemplatesPath();
+
+  const templatePath = path.join(
+    templateBaseDir,
+    config.framework,
+    config.architecture,
+    config.database,
+  );
+
+  if (!(await exists(templatePath))) {
+    throw new Error(`Template not found at: ${templatePath}`);
+  }
+
+  return templatePath;
+};

package/src/template-engine/index.ts

@@ -0,0 +1,21 @@
+import ejs from 'ejs';
+import fs from 'fs-extra';
+
+export const renderTemplate = async (
+  filePath: string,
+  data: Record<string, any>,
+): Promise<string> => {
+  const templateContent = await fs.readFile(filePath, 'utf-8');
+  return ejs.render(templateContent, data);
+};
+
+export const isTemplateFile = (filePath: string): boolean => {
+  return filePath.endsWith('.ejs');
+};
+
+export const getTargetFileName = (filePath: string): string => {
+  if (isTemplateFile(filePath)) {
+    return filePath.replace(/\.ejs$/, '');
+  }
+  return filePath;
+};

package/src/types.ts

@@ -0,0 +1,38 @@
+export type Framework = 'express';
+
+export type Architecture = 'traditional' | 'modular';
+
+export type Database = 'mongodb' | 'postgres';
+
+export type ORM = 'mongoose' | 'prisma';
+
+export type PackageManager = 'npm' | 'pnpm' | 'yarn';
+
+export interface GeneratorConfig {
+  projectName: string;
+  framework: Framework;
+  architecture: Architecture;
+  database: Database;
+  orm: ORM;
+  packageManager: PackageManager;
+  features: string[];
+}
+
+export interface FeatureMetadata {
+  name: string;
+  description: string;
+  frameworks?: Framework[];
+  architectures?: Architecture[];
+  databases?: Database[];
+}
+
+export interface FeatureDependencies {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+}
+
+export interface Feature {
+  metadata: FeatureMetadata;
+  dependencies: FeatureDependencies;
+  apply?: (projectPath: string, config: GeneratorConfig) => Promise<void>;
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}