create-craftjs 1.0.0

package/template/craft/commands/make-middleware.js

@@ -0,0 +1,46 @@
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+
+const toCamelCase = (str) =>
+  str
+    .toLowerCase()
+    .split("-")
+    .map((word, i) => (i === 0 ? word : word[0].toUpperCase() + word.slice(1)))
+    .join("");
+
+function makeMiddleware(name) {
+  if (!name) {
+    console.log(chalk.red("❌ Please provide a middleware name."));
+    return;
+  }
+
+  const className = `${toCamelCase(name)}Middleware`;
+  const fileName = `${name.toLowerCase()}-middleware.ts`;
+  const targetDir = path.resolve("src", "middleware");
+
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  const filePath = path.join(targetDir, fileName);
+  if (fs.existsSync(filePath)) {
+    console.log(chalk.yellow("⚠️ Middleware already exists."));
+    return;
+  }
+
+  const content = `import { NextFunction, Request, Response } from "express";
+
+export const ${className} = async (
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  next();
+};
+`;
+
+  fs.writeFileSync(filePath, content);
+  console.log(chalk.green(`✅ Middleware created at ${filePath}`));
+}
+module.exports = makeMiddleware;

package/template/craft/commands/make-repository.js

@@ -0,0 +1,36 @@
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+const toPascalCase = (str) =>
+  str.replace(/(^\w|-\w)/g, (m) => m.replace("-", "").toUpperCase());
+
+function makeRepository(name) {
+  if (!name) {
+    console.log(chalk.red("❌ Please provide a repository name."));
+    return;
+  }
+
+  const className = `${toPascalCase(name)}Repository`;
+  const fileName = `${name.toLowerCase()}-repository.ts`;
+  const targetDir = path.resolve("src", "repositories");
+
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  const filePath = path.join(targetDir, fileName);
+  if (fs.existsSync(filePath)) {
+    console.log(chalk.yellow("⚠️ Repository already exists."));
+    return;
+  }
+
+  const content = `import { prismaClient } from "../config/database";
+
+export class ${className} {
+}
+`;
+
+  fs.writeFileSync(filePath, content);
+  console.log(chalk.green(`✅ Repository created at ${filePath}`));
+}
+module.exports = makeRepository;

package/template/craft/commands/make-route.js

@@ -0,0 +1,88 @@
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+
+const toPascalCase = (str) =>
+  str.replace(/(^\w|-\w)/g, (m) => m.replace("-", "").toUpperCase());
+
+function makeRoute(name) {
+  if (!name) {
+    console.log(chalk.red("❌ Please provide a route name."));
+    return;
+  }
+
+  const routeName = name.toLowerCase();
+  const className = `${toPascalCase(name)}Controller`;
+  const routeConst = `${routeName}Router`;
+  const fileName = `${routeName}-route.ts`;
+  const targetDir = path.resolve("src", "routes");
+
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  const filePath = path.join(targetDir, fileName);
+  if (fs.existsSync(filePath)) {
+    console.log(chalk.yellow("⚠️ Route already exists."));
+    return;
+  }
+
+  const content = `import express from "express";
+import { asyncHandler } from "../utils/async-handler";
+import { authMiddleware } from "../middleware/auth-middleware";
+
+import { ${className} } from "../controllers/${routeName}-controller";
+
+export const ${routeConst} = express.Router();
+
+// Example routes:
+${routeConst}.get("/api/${routeName}s", asyncHandler(authMiddleware), ${className}.index);
+`;
+
+  fs.writeFileSync(filePath, content);
+  console.log(chalk.green(`✅ Route created at ${filePath}`));
+
+  const mainRouterPath = path.resolve("src", "routes", "main-route.ts");
+
+  if (fs.existsSync(mainRouterPath)) {
+    let mainRouterContent = fs.readFileSync(mainRouterPath, "utf-8");
+
+    const importStatement = `import { ${routeConst} } from "./${routeName}-route";`;
+    const useStatement = `mainRouter.use(${routeConst});`;
+
+    if (!mainRouterContent.includes(importStatement)) {
+      const lines = mainRouterContent.split("\n");
+      const importIndex = lines.findIndex((line) => line.startsWith("import"));
+      const lastImportIndex = [...lines]
+        .reverse()
+        .findIndex((line) => line.startsWith("import"));
+      const insertIndex =
+        lastImportIndex >= 0 ? lines.length - lastImportIndex : 0;
+      lines.splice(insertIndex, 0, importStatement);
+      mainRouterContent = lines.join("\n");
+    }
+
+    if (!mainRouterContent.includes(useStatement)) {
+      const routerEndIndex = mainRouterContent.lastIndexOf("mainRouter.use(");
+      const insertIndex =
+        routerEndIndex >= 0
+          ? mainRouterContent.indexOf("\n", routerEndIndex) + 1
+          : mainRouterContent.length;
+
+      mainRouterContent =
+        mainRouterContent.slice(0, insertIndex) +
+        useStatement +
+        "\n" +
+        mainRouterContent.slice(insertIndex);
+    }
+
+    fs.writeFileSync(mainRouterPath, mainRouterContent);
+    console.log(chalk.green("✅ Route registered in main-router."));
+  } else {
+    console.log(
+      chalk.yellow("⚠️ main-route.ts not found. Please register manually.")
+    );
+  }
+}
+
+module.exports = makeRoute;

package/template/craft/commands/make-service.js

@@ -0,0 +1,39 @@
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+
+const toPascalCase = (str) =>
+  str.replace(/(^\w|-\w)/g, (m) => m.replace("-", "").toUpperCase());
+
+function makeService(name) {
+  if (!name) {
+    console.log(chalk.red("❌ Please provide a service name."));
+    return;
+  }
+
+  const className = `${toPascalCase(name)}Service`;
+  const fileName = `${name.toLowerCase()}-service.ts`;
+  const targetDir = path.resolve("src", "services");
+
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  const filePath = path.join(targetDir, fileName);
+  if (fs.existsSync(filePath)) {
+    console.log(chalk.yellow("⚠️ Service already exists."));
+    return;
+  }
+
+  const content = `export class ${className} {
+  async doSomething() {
+    return "Service ${className} is working";
+  }
+}
+`;
+
+  fs.writeFileSync(filePath, content);
+  console.log(chalk.green(`✅ Service created at ${filePath}`));
+}
+
+module.exports = makeService;

package/template/craft/commands/make-test.js

@@ -0,0 +1,48 @@
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+
+function MakeTest(name) {
+  if (!name) {
+    console.log(chalk.red("❌ Please provide a test file name."));
+    process.exit(1);
+  }
+
+  const testDir = path.resolve(process.cwd(), "test");
+  if (!fs.existsSync(testDir)) {
+    fs.mkdirSync(testDir, { recursive: true });
+  }
+
+  const fileName = name.endsWith(".test.ts") ? name : `${name}.test.ts`;
+  const filePath = path.join(testDir, fileName);
+
+  if (fs.existsSync(filePath)) {
+    console.log(chalk.red(`❌ Test file already exists: ${fileName}`));
+    process.exit(1);
+  }
+
+  const template = `import supertest from "supertest";
+import { web } from "../src/application/web";
+import { logger } from "../src/application/logging";
+
+// example
+describe("POST /api/users", () => {
+  it("should register new user", async () => {
+    const response = await supertest(web).post("/api/auth/register").send({
+      fullName: "test",
+      email: "testing@gmail.com",
+      password: "12345678",
+    });
+    logger.debug(response.body);
+    expect(response.status).toBe(201);
+    expect(response.body.data.fullName).toBe("test");
+    expect(response.body.data.email).toBe("testing@gmail.com");
+  });
+});
+`;
+
+  fs.writeFileSync(filePath, template, "utf-8");
+  console.log(chalk.green(`✅ Test file created at: ${filePath}`));
+}
+
+module.exports = MakeTest;

package/template/craft/commands/make-utils.js

@@ -0,0 +1,30 @@
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+
+function makeUtils(name) {
+  if (!name) {
+    console.log(chalk.red("❌ Please provide a utils name."));
+    return;
+  }
+
+  const fileName = `${name.toLowerCase()}.ts`;
+  const targetDir = path.resolve("src", "utils");
+
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  const filePath = path.join(targetDir, fileName);
+  if (fs.existsSync(filePath)) {
+    console.log(chalk.yellow("⚠️ Utils already exists."));
+    return;
+  }
+
+  const content = ``;
+
+  fs.writeFileSync(filePath, content);
+  console.log(chalk.green(`✅ Utils created at ${filePath}`));
+}
+
+module.exports = makeUtils;

package/template/craft/commands/make-validation.js

@@ -0,0 +1,42 @@
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+
+const toPascalCase = (str) =>
+  str.replace(/(^\w|-\w)/g, (m) => m.replace("-", "").toUpperCase());
+
+function makeValidation(name) {
+  if (!name) {
+    console.log(chalk.red("❌ Please provide a validation name."));
+    return;
+  }
+
+  const className = `${toPascalCase(name)}Validation`;
+  const fileName = `${name.toLowerCase()}-validation.ts`;
+  const targetDir = path.resolve("src", "validations");
+
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  const filePath = path.join(targetDir, fileName);
+  if (fs.existsSync(filePath)) {
+    console.log(chalk.yellow("⚠️ Validation already exists."));
+    return;
+  }
+
+  const content = `import { z, ZodType } from "zod";
+
+export class ${className} {
+  static readonly CREATE: ZodType = z.object({
+    field1: z.string().min(1, { message: "Field1 wajib diisi" }),
+    field2: z.number().optional(),
+  });
+
+}
+`;
+
+  fs.writeFileSync(filePath, content);
+  console.log(chalk.green(`✅ Validation created at ${filePath}`));
+}
+module.exports = makeValidation;

package/template/craft/commands/make-view.js

@@ -0,0 +1,42 @@
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+
+function makeView(name) {
+  if (!name) {
+    console.log(chalk.red("❌ Please provide a view name."));
+    return;
+  }
+
+  const fileName = `${name.toLowerCase()}.ejs`;
+  const targetDir = path.resolve("src", "views");
+
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  const filePath = path.join(targetDir, fileName);
+  if (fs.existsSync(filePath)) {
+    console.log(chalk.yellow("⚠️ View already exists."));
+    return;
+  }
+
+  const content = `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title><%= title %></title>
+  </head>
+  <body
+  <p>${name}</p>
+  </body>
+</html>
+}
+`;
+
+  fs.writeFileSync(filePath, content);
+  console.log(chalk.green(`✅ View created at ${filePath}`));
+}
+
+module.exports = makeView;

package/template/craft/commands/start.js

@@ -0,0 +1,29 @@
+const { spawnSync } = require("child_process");
+const chalk = require("chalk");
+const fs = require("fs");
+const path = require("path");
+
+function Start() {
+  const entryPoint = path.resolve("dist/main.js");
+
+  if (!fs.existsSync(entryPoint)) {
+    console.error(
+      chalk.red(
+        `❌ Build file not found: ${entryPoint}\nPlease run 'node craft build' before starting the production server.`
+      )
+    );
+    process.exit(1);
+  }
+
+  console.log(chalk.blue("🚀 Starting production server...."));
+  const result = spawnSync("node", [entryPoint], {
+    stdio: "inherit",
+    shell: true,
+  });
+
+  if (result.status !== 0) {
+    console.error(chalk.red("❌ Failed to start production server."));
+    process.exit(result.status ?? 1);
+  }
+}
+module.exports = Start;

package/template/craft/commands/test.js

@@ -0,0 +1,20 @@
+const { spawnSync } = require("child_process");
+const chalk = require("chalk");
+
+function RunTest() {
+  console.log(chalk.blue("🧪 Running tests..."));
+
+  const result = spawnSync("npx", ["jest", "-i"], {
+    stdio: "inherit",
+    shell: true,
+  });
+
+  if (result.status !== 0) {
+    console.error(chalk.red("❌ Tests failed."));
+    process.exit(result.status ?? 1);
+  } else {
+    console.log(chalk.green("✅ Tests passed."));
+  }
+}
+
+module.exports = RunTest;

package/template/craft.js

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+
+const yargs = require("yargs");
+const { hideBin } = require("yargs/helpers");
+
+yargs(hideBin(process.argv))
+  .command(
+    "build",
+    "Building project to production ",
+    () => {},
+    () => {
+      const build = require("./craft/commands/build.js");
+      build();
+    }
+  )
+  .command(
+    "db:generate",
+    "Running prisma generate",
+    () => {},
+    () => {
+      const dbgenerate = require("./craft/commands/db-generate.js");
+      dbgenerate();
+    }
+  )
+  .command(
+    "db:migrate",
+    "Running prisma migration",
+    () => {},
+    () => {
+      const migrate = require("./craft/commands/db-migrate.js");
+      migrate();
+    }
+  )
+  .command(
+    "db:fresh",
+    "Running prisma migrate fresh",
+    () => {},
+    () => {
+      const dbfresh = require("./craft/commands/db-fresh.js");
+      dbfresh();
+    }
+  )
+  .command(
+    "dev",
+    "Starting development server",
+    () => {},
+    () => {
+      const dev = require("./craft/commands/dev.js");
+      dev();
+    }
+  )
+  .command(
+    "key:generate",
+    "Generate JWT SECRET KEY",
+    () => {},
+    () => {
+      const dev = require("./craft/commands/key-generate.js");
+      dev();
+    }
+  )
+  .command(
+    "make:apidocs <name>",
+    "Generate a new api documentation",
+    (yargs) => {
+      yargs.positional("name", {
+        describe: "apidocs name",
+        type: "string",
+      });
+    },
+    (argv) => {
+      const makeapidocs = require("./craft/commands/make-apidocs.js");
+      makeapidocs(argv.name);
+    }
+  )
+  .command(
+    "make:command <name>",
+    "Generate a new craft command",
+    (yargs) => {
+      yargs.positional("name", {
+        describe: "Command name",
+        type: "string",
+      });
+    },
+    (argv) => {
+      const makecommand = require("./craft/commands/make-command.js");
+      makecommand(argv.name);
+    }
+  )
+  .command(
+    "make:controller <name>",
+    "Generate a new controller",
+    (yargs) => {
+      yargs
+        .positional("name", {
+          describe: "Controller name",
+          type: "string",
+        })
+        .option("resource", {
+          describe: "Generate resource style controller methods",
+          type: "boolean",
+          default: false,
+        });
+    },
+    (argv) => {
+      const makecontroller = require("./craft/commands/make-controller.js");
+      makecontroller(argv.name, { resource: argv.resource });
+    }
+  )
+  .command(
+    "make:middleware <name>",
+    "Generate a new middleware",
+    (yargs) => {
+      yargs.positional("name", {
+        describe: "Middleware name",
+        type: "string",
+      });
+    },
+    (argv) => {
+      const makemiddleware = require("./craft/commands/make-middleware.js");
+      makemiddleware(argv.name);
+    }
+  )
+  .command(
+    "make:repository <name>",
+    "Generate a new respository",
+    (yargs) => {
+      yargs.positional("name", {
+        describe: "Repository name",
+        type: "string",
+      });
+    },
+    (argv) => {
+      const makerepository = require("./craft/commands/make-repository.js");
+      makerepository(argv.name);
+    }
+  )
+  .command(
+    "make:dto <name>",
+    "Generate a new dto",
+    (yargs) => {
+      yargs.positional("name", {
+        describe: "Dto name",
+        type: "string",
+      });
+    },
+    (argv) => {
+      const makedto = require("./craft/commands/make-dto.js");
+      makedto(argv.name);
+    }
+  )
+  .command(
+    "make:route <name>",
+    "Generate a new route",
+    (yargs) => {
+      yargs.positional("name", {
+        describe: "Route name",
+        type: "string",
+      });
+    },
+    (argv) => {
+      const makeroute = require("./craft/commands/make-route.js");
+      makeroute(argv.name);
+    }
+  )
+  .command(
+    "make:service <name>",
+    "Generate a new service",
+    (yargs) => {
+      yargs.positional("name", {
+        describe: "Service name",
+        type: "string",
+      });
+    },
+    (argv) => {
+      const makeservice = require("./craft/commands/make-service.js");
+      makeservice(argv.name);
+    }
+  )
+  .command(
+    "make:test <name>",
+    "Generate a new unit test",
+    (yargs) => {
+      yargs.positional("name", {
+        describe: "Test name",
+        type: "string",
+      });
+    },
+    (argv) => {
+      const maketest = require("./craft/commands/make-test.js");
+      maketest(argv.name);
+    }
+  )
+  .command(
+    "make:utils <name>",
+    "Generate a new utils",
+    (yargs) => {
+      yargs.positional("name", {
+        describe: "Utils name",
+        type: "string",
+      });
+    },
+    (argv) => {
+      const makeutils = require("./craft/commands/make-utils.js");
+      makeutils(argv.name);
+    }
+  )
+  .command(
+    "make:validation <name>",
+    "Generate a new validation",
+    (yargs) => {
+      yargs.positional("name", {
+        describe: "Validation name",
+        type: "string",
+      });
+    },
+    (argv) => {
+      const makevalidation = require("./craft/commands/make-validation.js");
+      makevalidation(argv.name);
+    }
+  )
+  .command(
+    "make:view <name>",
+    "Generate a new view",
+    (yargs) => {
+      yargs.positional("name", {
+        describe: "View name",
+        type: "string",
+      });
+    },
+    (argv) => {
+      const makeview = require("./craft/commands/make-view.js");
+      makeview(argv.name);
+    }
+  )
+  .command(
+    "start",
+    "Starting production server",
+    () => {},
+    () => {
+      const start = require("./craft/commands/start.js");
+      start();
+    }
+  )
+  .command(
+    "test",
+    "Run Jest unit tests",
+    () => {},
+    () => {
+      const runtest = require("./craft/commands/test.js");
+      runtest();
+    }
+  )
+  .demandCommand()
+  .strict()
+  .help()
+  .parse();

package/template/nodemon.json

@@ -0,0 +1,6 @@
+{
+  "ignore": [".git", "node_modules", "dist"],
+  "watch": ["src", ".env"],
+  "exec": "ts-node ./src/main.ts",
+  "ext": "ts"
+}