@erwininteractive/mvc 0.1.1

package/dist/framework/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerController = exports.registerControllers = exports.authenticate = exports.verifyToken = exports.signToken = exports.verifyPassword = exports.hashPassword = exports.disconnectPrisma = exports.getPrismaClient = exports.startServer = exports.createMvcApp = void 0;
+// App factory and server
+var App_1 = require("./App");
+Object.defineProperty(exports, "createMvcApp", { enumerable: true, get: function () { return App_1.createMvcApp; } });
+Object.defineProperty(exports, "startServer", { enumerable: true, get: function () { return App_1.startServer; } });
+// Database
+var db_1 = require("./db");
+Object.defineProperty(exports, "getPrismaClient", { enumerable: true, get: function () { return db_1.getPrismaClient; } });
+Object.defineProperty(exports, "disconnectPrisma", { enumerable: true, get: function () { return db_1.disconnectPrisma; } });
+// Authentication
+var Auth_1 = require("./Auth");
+Object.defineProperty(exports, "hashPassword", { enumerable: true, get: function () { return Auth_1.hashPassword; } });
+Object.defineProperty(exports, "verifyPassword", { enumerable: true, get: function () { return Auth_1.verifyPassword; } });
+Object.defineProperty(exports, "signToken", { enumerable: true, get: function () { return Auth_1.signToken; } });
+Object.defineProperty(exports, "verifyToken", { enumerable: true, get: function () { return Auth_1.verifyToken; } });
+Object.defineProperty(exports, "authenticate", { enumerable: true, get: function () { return Auth_1.authenticate; } });
+// Routing
+var Router_1 = require("./Router");
+Object.defineProperty(exports, "registerControllers", { enumerable: true, get: function () { return Router_1.registerControllers; } });
+Object.defineProperty(exports, "registerController", { enumerable: true, get: function () { return Router_1.registerController; } });

package/dist/generators/generateController.d.ts

@@ -0,0 +1,7 @@
+export interface GenerateControllerOptions {
+    views?: boolean;
+}
+/**
+ * Generate a CRUD controller.
+ */
+export declare function generateController(name: string, options?: GenerateControllerOptions): Promise<void>;

package/dist/generators/generateController.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateController = generateController;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ejs_1 = __importDefault(require("ejs"));
+const paths_1 = require("./paths");
+/**
+ * Generate a CRUD controller.
+ */
+async function generateController(name, options = {}) {
+    const { views = true } = options;
+    const modelName = capitalize(name);
+    const lowerModelName = name.toLowerCase();
+    const controllerName = `${modelName}Controller`;
+    const resourcePath = pluralize(lowerModelName);
+    console.log(`Generating controller: ${controllerName}`);
+    // Ensure controllers directory exists
+    const controllersDir = path_1.default.resolve("src/controllers");
+    if (!fs_1.default.existsSync(controllersDir)) {
+        fs_1.default.mkdirSync(controllersDir, { recursive: true });
+    }
+    // Load and render controller template
+    const templatePath = path_1.default.join((0, paths_1.getTemplatesDir)(), "controller.ts.ejs");
+    if (!fs_1.default.existsSync(templatePath)) {
+        throw new Error("Controller template not found");
+    }
+    const template = fs_1.default.readFileSync(templatePath, "utf-8");
+    const controllerContent = ejs_1.default.render(template, {
+        modelName,
+        lowerModelName,
+        controllerName,
+        resourcePath,
+    });
+    // Write controller file
+    const controllerPath = path_1.default.join(controllersDir, `${controllerName}.ts`);
+    if (fs_1.default.existsSync(controllerPath)) {
+        throw new Error(`Controller ${controllerName}.ts already exists`);
+    }
+    fs_1.default.writeFileSync(controllerPath, controllerContent);
+    console.log(`Created src/controllers/${controllerName}.ts`);
+    // Generate views if enabled
+    if (views) {
+        await generateViews(lowerModelName, modelName);
+    }
+    console.log(`
+Controller ${controllerName} created successfully!
+
+Routes:
+  GET    /${resourcePath}       -> index
+  GET    /${resourcePath}/:id   -> show
+  POST   /${resourcePath}       -> store
+  PUT    /${resourcePath}/:id   -> update
+  DELETE /${resourcePath}/:id   -> destroy
+`);
+}
+/**
+ * Generate basic views for a resource.
+ */
+async function generateViews(lowerName, modelName) {
+    const viewsDir = path_1.default.resolve(`src/views/${lowerName}`);
+    if (!fs_1.default.existsSync(viewsDir)) {
+        fs_1.default.mkdirSync(viewsDir, { recursive: true });
+    }
+    // Load view template
+    const viewTemplatePath = path_1.default.join((0, paths_1.getTemplatesDir)(), "view.ejs.ejs");
+    if (!fs_1.default.existsSync(viewTemplatePath)) {
+        console.warn("View template not found, skipping view generation");
+        return;
+    }
+    const viewTemplate = fs_1.default.readFileSync(viewTemplatePath, "utf-8");
+    // Generate index view
+    const indexContent = ejs_1.default.render(viewTemplate, {
+        title: `${modelName} List`,
+        modelName,
+        lowerName,
+        viewType: "index",
+    });
+    fs_1.default.writeFileSync(path_1.default.join(viewsDir, "index.ejs"), indexContent);
+    // Generate show view
+    const showContent = ejs_1.default.render(viewTemplate, {
+        title: `${modelName} Details`,
+        modelName,
+        lowerName,
+        viewType: "show",
+    });
+    fs_1.default.writeFileSync(path_1.default.join(viewsDir, "show.ejs"), showContent);
+    console.log(`Created views in src/views/${lowerName}/`);
+}
+/**
+ * Capitalize the first letter of a string.
+ */
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * Simple pluralization.
+ */
+function pluralize(str) {
+    if (str.endsWith("s")) {
+        return str;
+    }
+    if (str.endsWith("y")) {
+        return str.slice(0, -1) + "ies";
+    }
+    return str + "s";
+}

package/dist/generators/generateModel.d.ts

@@ -0,0 +1,7 @@
+export interface GenerateModelOptions {
+    skipMigrate?: boolean;
+}
+/**
+ * Generate a Prisma model and append it to schema.prisma.
+ */
+export declare function generateModel(name: string, options?: GenerateModelOptions): Promise<void>;

package/dist/generators/generateModel.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModel = generateModel;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ejs_1 = __importDefault(require("ejs"));
+const child_process_1 = require("child_process");
+const paths_1 = require("./paths");
+/**
+ * Generate a Prisma model and append it to schema.prisma.
+ */
+async function generateModel(name, options = {}) {
+    const modelName = capitalize(name);
+    const tableName = pluralize(name.toLowerCase());
+    console.log(`Generating model: ${modelName}`);
+    // Find prisma schema
+    const schemaPath = path_1.default.resolve("prisma/schema.prisma");
+    if (!fs_1.default.existsSync(schemaPath)) {
+        throw new Error("prisma/schema.prisma not found. Are you in a project directory?");
+    }
+    // Load and render template
+    const templatePath = path_1.default.join((0, paths_1.getTemplatesDir)(), "model.prisma.ejs");
+    if (!fs_1.default.existsSync(templatePath)) {
+        throw new Error("Model template not found");
+    }
+    const template = fs_1.default.readFileSync(templatePath, "utf-8");
+    const modelContent = ejs_1.default.render(template, { modelName, tableName });
+    // Check if model already exists
+    const existingSchema = fs_1.default.readFileSync(schemaPath, "utf-8");
+    if (existingSchema.includes(`model ${modelName} {`)) {
+        throw new Error(`Model ${modelName} already exists in schema.prisma`);
+    }
+    // Append model to schema
+    fs_1.default.appendFileSync(schemaPath, "\n" + modelContent);
+    console.log(`Added model ${modelName} to prisma/schema.prisma`);
+    // Run Prisma migrate
+    if (!options.skipMigrate) {
+        console.log("\nRunning Prisma migrate...");
+        try {
+            (0, child_process_1.execSync)(`npx prisma migrate dev --name add-${name.toLowerCase()}`, {
+                stdio: "inherit",
+            });
+        }
+        catch {
+            console.error("Migration failed. You may need to run it manually.");
+        }
+        console.log("\nGenerating Prisma client...");
+        try {
+            (0, child_process_1.execSync)("npx prisma generate", { stdio: "inherit" });
+        }
+        catch {
+            console.error("Failed to generate Prisma client.");
+        }
+    }
+    console.log(`\nModel ${modelName} created successfully!`);
+}
+/**
+ * Capitalize the first letter of a string.
+ */
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * Simple pluralization - add 's' if not already ending in 's'.
+ */
+function pluralize(str) {
+    if (str.endsWith("s")) {
+        return str;
+    }
+    if (str.endsWith("y")) {
+        return str.slice(0, -1) + "ies";
+    }
+    return str + "s";
+}

package/dist/generators/initApp.d.ts

@@ -0,0 +1,8 @@
+export interface InitOptions {
+    skipInstall?: boolean;
+    withDatabase?: boolean;
+}
+/**
+ * Scaffold a new MVC application.
+ */
+export declare function initApp(dir: string, options?: InitOptions): Promise<void>;

package/dist/generators/initApp.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initApp = initApp;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const paths_1 = require("./paths");
+/**
+ * Scaffold a new MVC application.
+ */
+async function initApp(dir, options = {}) {
+    const targetDir = path_1.default.resolve(dir);
+    const templateDir = path_1.default.join((0, paths_1.getTemplatesDir)(), "appScaffold");
+    console.log(`Creating new MVC application in ${targetDir}...`);
+    // Create target directory
+    if (!fs_1.default.existsSync(targetDir)) {
+        fs_1.default.mkdirSync(targetDir, { recursive: true });
+    }
+    // Copy app scaffold templates
+    copyDirRecursive(templateDir, targetDir);
+    // Copy .env.example
+    const envExample = (0, paths_1.getEnvExamplePath)();
+    if (fs_1.default.existsSync(envExample)) {
+        fs_1.default.copyFileSync(envExample, path_1.default.join(targetDir, ".env.example"));
+    }
+    // Update package.json with app name and framework path
+    const appPackageJson = path_1.default.join(targetDir, "package.json");
+    if (fs_1.default.existsSync(appPackageJson)) {
+        const pkg = JSON.parse(fs_1.default.readFileSync(appPackageJson, "utf-8"));
+        pkg.name = path_1.default.basename(dir);
+        // Use relative path to framework for local development
+        // When published, this would be the npm package version
+        const frameworkRoot = (0, paths_1.getPackageRoot)();
+        const relativePath = path_1.default.relative(targetDir, frameworkRoot);
+        pkg.dependencies["@erwininteractive/mvc"] = `file:${relativePath}`;
+        fs_1.default.writeFileSync(appPackageJson, JSON.stringify(pkg, null, 2));
+    }
+    console.log("Application scaffolded successfully!");
+    // Install dependencies
+    if (!options.skipInstall) {
+        console.log("\nInstalling dependencies...");
+        try {
+            (0, child_process_1.execSync)("npm install", { cwd: targetDir, stdio: "inherit" });
+        }
+        catch {
+            console.error("Failed to install dependencies. Please run 'npm install' manually.");
+        }
+    }
+    // Setup database if requested
+    if (options.withDatabase) {
+        setupDatabase(targetDir);
+    }
+    console.log(`
+Next steps:
+  cd ${dir}
+  npm run dev
+
+Your app is ready! Visit http://localhost:3000
+${!options.withDatabase ? `
+To add database support later:
+  npm run db:setup
+  # Edit .env with DATABASE_URL
+  npx prisma migrate dev --name init
+` : ""}`);
+}
+/**
+ * Setup Prisma database support.
+ */
+function setupDatabase(targetDir) {
+    // Copy prisma schema
+    const prismaDir = path_1.default.join(targetDir, "prisma");
+    if (!fs_1.default.existsSync(prismaDir)) {
+        fs_1.default.mkdirSync(prismaDir, { recursive: true });
+    }
+    const frameworkPrismaSchema = path_1.default.join((0, paths_1.getPrismaDir)(), "schema.prisma");
+    if (fs_1.default.existsSync(frameworkPrismaSchema)) {
+        fs_1.default.copyFileSync(frameworkPrismaSchema, path_1.default.join(prismaDir, "schema.prisma"));
+    }
+    // Install Prisma
+    console.log("\nSetting up database...");
+    try {
+        (0, child_process_1.execSync)("npm install @prisma/client prisma", { cwd: targetDir, stdio: "inherit" });
+        (0, child_process_1.execSync)("npx prisma generate", { cwd: targetDir, stdio: "inherit" });
+    }
+    catch {
+        console.error("Failed to setup Prisma. Run 'npm run db:setup' manually.");
+    }
+}
+/**
+ * Recursively copy a directory.
+ */
+function copyDirRecursive(src, dest) {
+    if (!fs_1.default.existsSync(src)) {
+        return;
+    }
+    if (!fs_1.default.existsSync(dest)) {
+        fs_1.default.mkdirSync(dest, { recursive: true });
+    }
+    const entries = fs_1.default.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path_1.default.join(src, entry.name);
+        const destPath = path_1.default.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirRecursive(srcPath, destPath);
+        }
+        else {
+            fs_1.default.copyFileSync(srcPath, destPath);
+        }
+    }
+}

package/dist/generators/paths.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Get the root directory of the framework package.
+ * Works whether running from src/ (development) or dist/ (production).
+ */
+export declare function getPackageRoot(): string;
+/**
+ * Get the templates directory path.
+ */
+export declare function getTemplatesDir(): string;
+/**
+ * Get the prisma directory path.
+ */
+export declare function getPrismaDir(): string;
+/**
+ * Get the .env.example file path.
+ */
+export declare function getEnvExamplePath(): string;

package/dist/generators/paths.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageRoot = getPackageRoot;
+exports.getTemplatesDir = getTemplatesDir;
+exports.getPrismaDir = getPrismaDir;
+exports.getEnvExamplePath = getEnvExamplePath;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+/**
+ * Get the root directory of the framework package.
+ * Works whether running from src/ (development) or dist/ (production).
+ */
+function getPackageRoot() {
+    // Start from this file's directory and walk up to find package.json
+    let dir = __dirname;
+    // Walk up at most 5 levels to find package.json with our package name
+    for (let i = 0; i < 5; i++) {
+        const packageJsonPath = path_1.default.join(dir, "package.json");
+        if (fs_1.default.existsSync(packageJsonPath)) {
+            try {
+                const pkg = JSON.parse(fs_1.default.readFileSync(packageJsonPath, "utf-8"));
+                if (pkg.name === "@erwininteractive/mvc") {
+                    return dir;
+                }
+            }
+            catch {
+                // Continue searching
+            }
+        }
+        dir = path_1.default.dirname(dir);
+    }
+    // Fallback: assume we're in dist/generators or src/generators
+    return path_1.default.resolve(__dirname, "../..");
+}
+/**
+ * Get the templates directory path.
+ */
+function getTemplatesDir() {
+    return path_1.default.join(getPackageRoot(), "templates");
+}
+/**
+ * Get the prisma directory path.
+ */
+function getPrismaDir() {
+    return path_1.default.join(getPackageRoot(), "prisma");
+}
+/**
+ * Get the .env.example file path.
+ */
+function getEnvExamplePath() {
+    return path_1.default.join(getPackageRoot(), ".env.example");
+}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@erwininteractive/mvc",
+  "version": "0.1.1",
+  "description": "A lightweight, full-featured MVC framework for Node.js with Express, Prisma, and EJS",
+  "main": "dist/framework/index.js",
+  "types": "dist/framework/index.d.ts",
+  "bin": {
+    "erwinmvc": "dist/cli.js"
+  },
+  "files": [
+    "dist/**",
+    "prisma/**",
+    "templates/**",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/build-cli.js",
+    "dev": "tsx src/cli.ts",
+    "test": "jest",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "mvc",
+    "framework",
+    "express",
+    "prisma",
+    "ejs",
+    "typescript",
+    "node"
+  ],
+  "author": "Erwin Interactive",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/erwininteractive/mvc.git"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@prisma/client": "^6.0.0",
+    "bcryptjs": "^2.4.3",
+    "commander": "^12.1.0",
+    "connect-redis": "^7.1.1",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.5",
+    "ejs": "^3.1.10",
+    "express": "^4.21.0",
+    "express-session": "^1.18.0",
+    "helmet": "^8.0.0",
+    "jsonwebtoken": "^9.0.2",
+    "prisma": "^6.0.0",
+    "redis": "^4.7.0"
+  },
+  "devDependencies": {
+    "@types/bcryptjs": "^2.4.6",
+    "@types/cors": "^2.8.17",
+    "@types/ejs": "^3.1.5",
+    "@types/express": "^5.0.0",
+    "@types/express-session": "^1.18.0",
+    "@types/jest": "^29.5.13",
+    "@types/jsonwebtoken": "^9.0.7",
+    "@types/node": "^22.7.5",
+    "@types/supertest": "^6.0.2",
+    "esbuild": "^0.24.0",
+    "jest": "^29.7.0",
+    "supertest": "^7.0.0",
+    "ts-jest": "^29.2.5",
+    "tsx": "^4.19.1",
+    "typescript": "^5.6.3"
+  }
+}

package/prisma/schema.prisma

@@ -0,0 +1,19 @@
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id             Int      @id @default(autoincrement())
+  email          String   @unique
+  hashedPassword String
+  role           String   @default("user")
+  createdAt      DateTime @default(now())
+  updatedAt      DateTime @updatedAt
+
+  @@map("users")
+}