stackkit 0.3.4 → 0.3.6

package/modules/storage/cloudinary/files/express/config/env.ts

@@ -0,0 +1,65 @@
+import dotenv from "dotenv";
+import status from "http-status";
+import path from "path";
+import { AppError } from "../shared/errors/app-error";
+
+dotenv.config({ path: path.join(process.cwd(), ".env") });
+
+interface EnvConfig {
+  NODE_ENV: string;
+  PORT: string;
+  APP_NAME?: string;
+  APP_URL: string;
+  {{#if database}}
+  DATABASE_URL: string;
+  {{/if}}
+  CLOUDINARY: {
+    CLOUDINARY_CLOUD_NAME: string;
+    CLOUDINARY_API_KEY: string;
+    CLOUDINARY_API_SECRET: string;
+    CLOUDINARY_UPLOAD_PRESET?: string;
+  };
+}
+
+const loadEnvVars = (): EnvConfig => {
+  const requiredEnvVars = [
+    "NODE_ENV",
+    "PORT",
+    "APP_NAME",
+    "APP_URL",
+    {{#if database}}
+    "DATABASE_URL",
+    {{/if}}
+    "CLOUDINARY_CLOUD_NAME",
+    "CLOUDINARY_API_KEY",
+    "CLOUDINARY_API_SECRET",
+  ];
+
+  requiredEnvVars.forEach((varName) => {
+    if (!process.env[varName]) {
+      throw new AppError(
+        status.INTERNAL_SERVER_ERROR,
+        `Environment variable ${varName} is required but not set in .env file.`,
+      );
+    }
+  });
+
+  return {
+    NODE_ENV: process.env.NODE_ENV as string,
+    PORT: process.env.PORT as string,
+    APP_NAME: process.env.APP_NAME ?? "Your App",
+    APP_URL: process.env.APP_URL as string,
+    {{#if database}}
+    DATABASE_URL: process.env.DATABASE_URL as string,
+    {{/if}}
+    CLOUDINARY: {
+      CLOUDINARY_CLOUD_NAME: process.env.CLOUDINARY_CLOUD_NAME as string,
+      CLOUDINARY_API_KEY: process.env.CLOUDINARY_API_KEY as string,
+      CLOUDINARY_API_SECRET: process.env.CLOUDINARY_API_SECRET as string,
+      CLOUDINARY_UPLOAD_PRESET:
+        process.env.CLOUDINARY_UPLOAD_PRESET as string,
+    },
+  };
+};
+
+export const envVars = loadEnvVars();

package/modules/storage/cloudinary/files/express/config/media.ts

@@ -0,0 +1,103 @@
+import { v2 as cloudinary, UploadApiResponse } from "cloudinary";
+import status from "http-status";
+import { AppError } from "../shared/errors/app-error";
+import { envVars } from "./env";
+
+cloudinary.config({
+  cloud_name: envVars.CLOUDINARY.CLOUDINARY_CLOUD_NAME,
+  api_key: envVars.CLOUDINARY.CLOUDINARY_API_KEY,
+  api_secret: envVars.CLOUDINARY.CLOUDINARY_API_SECRET,
+});
+
+export const uploadFileToCloudinary = async (
+  buffer: Buffer,
+  fileName: string,
+): Promise<UploadApiResponse> => {
+  if (!buffer || !fileName) {
+    throw new AppError(
+      status.BAD_REQUEST,
+      "File buffer and file name are required for upload",
+    );
+  }
+
+  const extension = fileName.split(".").pop()?.toLocaleLowerCase();
+
+  const fileNameWithoutExtension = fileName
+    .split(".")
+    .slice(0, -1)
+    .join(".")
+    .toLowerCase()
+    .replace(/\s+/g, "-")
+    // eslint-disable-next-line no-useless-escape
+    .replace(/[^a-z0-9\-]/g, "");
+
+  const uniqueName =
+    Math.random().toString(36).substring(2) +
+    "-" +
+    Date.now() +
+    "-" +
+    fileNameWithoutExtension;
+
+  const folder =
+    extension === "pdf" ? "pdfs" : extension === "mp4" ? "videos" : "images";
+
+  return new Promise((resolve, reject) => {
+    cloudinary.uploader
+      .upload_stream(
+        {
+          resource_type: "auto",
+          public_id: `app/${folder}/${uniqueName}`,
+          folder: `app/${folder}`,
+        },
+        (error, result) => {
+          if (error) {
+            return reject(
+              new AppError(
+                status.INTERNAL_SERVER_ERROR,
+                "Failed to upload file to Cloudinary",
+              ),
+            );
+          }
+          resolve(result as UploadApiResponse);
+        },
+      )
+      .end(buffer);
+  });
+};
+
+export const deleteFileFromCloudinary = async (url: string) => {
+  try {
+    const regex = /\/v\d+\/(.+?)(?:\.[a-zA-Z0-9]+)+$/;
+
+    const match = url.match(regex);
+
+    if (match && match[1]) {
+      const publicId = match[1];
+
+      // try several resource types to ensure deletion for image/video/raw
+      const tryTypes: Array<"image" | "video" | "raw"> = [
+        "image",
+        "video",
+        "raw",
+      ];
+
+      for (const t of tryTypes) {
+        try {
+          await cloudinary.uploader.destroy(publicId, { resource_type: t });
+        } catch {
+          // continue trying other types
+        }
+      }
+
+      console.log(`File ${publicId} deleted from cloudinary`);
+    }
+  } catch (error) {
+    console.error("Error deleting file from Cloudinary:", error);
+    throw new AppError(
+      status.INTERNAL_SERVER_ERROR,
+      "Failed to delete file from Cloudinary",
+    );
+  }
+};
+
+export const cloudinaryUpload = cloudinary;

package/modules/storage/cloudinary/files/express/modules/media/media.controller.ts

@@ -0,0 +1,59 @@
+import { Request, Response } from "express";
+import status from "http-status";
+import { catchAsync } from "../../shared/utils/catch-async";
+import { sendResponse } from "../../shared/utils/send-response";
+import { mediaService } from "./media.service";
+import {
+  MediaSignInput,
+  mediaSignSchema,
+  mediaUploadDeleteSchema,
+  mediaUploadPresignSchema,
+} from "./media.type";
+
+const signMedia = catchAsync(async (req: Request, res: Response) => {
+  const publicId = req.params.publicId as string;
+  const transformation = (req.query.transformation as string) || undefined;
+
+  const payload = mediaSignSchema.parse({
+    publicId,
+    transformation,
+  }) as MediaSignInput;
+  const result = await mediaService.signMedia(payload);
+
+  sendResponse(res, {
+    status: status.OK,
+    success: true,
+    message: "Cloudinary URL generated",
+    data: result,
+  });
+});
+
+const createPresign = catchAsync(async (req: Request, res: Response) => {
+  const payload = mediaUploadPresignSchema.parse(req.body);
+  const result = await mediaService.createMediaPresign(payload);
+
+  sendResponse(res, {
+    status: status.OK,
+    success: true,
+    message: "Presigned upload created",
+    data: result,
+  });
+});
+
+const deleteUploads = catchAsync(async (req: Request, res: Response) => {
+  const payload = mediaUploadDeleteSchema.parse(req.body);
+  const result = await mediaService.deleteMediaUploads(payload);
+
+  sendResponse(res, {
+    status: status.OK,
+    success: true,
+    message: "Uploads deleted",
+    data: result,
+  });
+});
+
+export const mediaController = {
+  signMedia,
+  createPresign,
+  deleteUploads,
+};

package/modules/storage/cloudinary/files/express/modules/media/media.route.ts

@@ -0,0 +1,29 @@
+{{#if database == "prisma"}}
+import { Role } from "@prisma/client";
+{{/if}}
+{{#if database == "mongoose"}}
+import { Role } from "../../modules/auth/auth.constants";
+{{/if}}
+import { Router } from "express";
+import { authorize } from "../../shared/middlewares/authorize.middleware";
+import { mediaController } from "./media.controller";
+
+const router = Router();
+
+router.get(
+  "/:publicId/transform",
+  authorize(Role.ADMIN, Role.USER),
+  mediaController.signMedia,
+);
+router.post(
+  "/upload/presign",
+  authorize(Role.ADMIN, Role.USER),
+  mediaController.createPresign,
+);
+router.post(
+  "/upload/delete",
+  authorize(Role.ADMIN, Role.USER),
+  mediaController.deleteUploads,
+);
+
+export const mediaRoutes = router;

package/modules/storage/cloudinary/files/express/modules/media/media.service.ts

@@ -0,0 +1,113 @@
+import { envVars } from "../../config/env";
+import { cloudinaryUpload, deleteFileFromCloudinary } from "../../config/media";
+import {
+  MediaSignInput,
+  MediaUploadDeleteInput,
+  MediaUploadPresignInput,
+} from "./media.type";
+
+const signMedia = async (payload: MediaSignInput) => {
+  const { publicId, transformation } = payload;
+
+  const options = transformation ? { transformation } : undefined;
+
+  const url = cloudinaryUpload.url(publicId, options);
+
+  return { url };
+};
+
+const createMediaPresign = async (payload: MediaUploadPresignInput) => {
+  const timestamp = Math.floor(Date.now() / 1000);
+  const paramsToSign: Record<string, string | number> = { timestamp };
+
+  if (payload.folder) paramsToSign.folder = payload.folder;
+  if (payload.publicId) paramsToSign.public_id = payload.publicId;
+  if (payload.resourceType && payload.resourceType !== "auto")
+    paramsToSign.resource_type = payload.resourceType;
+
+  const resourceType = payload.resourceType || "auto";
+
+  // Unsigned flow: return upload_preset if configured
+  if (payload.unsigned) {
+    const upload_preset =
+      envVars.CLOUDINARY.CLOUDINARY_UPLOAD_PRESET ?? undefined;
+    const uploadUrl = `https://api.cloudinary.com/v1_1/${envVars.CLOUDINARY.CLOUDINARY_CLOUD_NAME}/${resourceType}/upload`;
+
+    return {
+      uploadUrl,
+      upload_preset,
+      unsigned: true,
+      folder: payload.folder,
+      publicId: payload.publicId,
+      resourceType: payload.resourceType,
+    };
+  }
+
+  const signature = cloudinaryUpload.utils.api_sign_request(
+    paramsToSign,
+    envVars.CLOUDINARY.CLOUDINARY_API_SECRET,
+  );
+
+  const uploadUrl = `https://api.cloudinary.com/v1_1/${envVars.CLOUDINARY.CLOUDINARY_CLOUD_NAME}/${resourceType}/upload`;
+
+  return {
+    uploadUrl,
+    api_key: envVars.CLOUDINARY.CLOUDINARY_API_KEY,
+    timestamp,
+    signature,
+    folder: payload.folder,
+    publicId: payload.publicId,
+    resourceType: payload.resourceType,
+    unsigned: false,
+  };
+};
+
+const deleteMediaUploads = async (payload: MediaUploadDeleteInput) => {
+  const keys = payload.keys ?? [];
+  const urls = payload.urls ?? [];
+
+  const deleted: string[] = [];
+  const failed: string[] = [];
+
+  for (const key of keys) {
+    try {
+      // try destroy across possible types
+      const tryTypes: Array<"image" | "video" | "raw"> = [
+        "image",
+        "video",
+        "raw",
+      ];
+      let ok = false;
+      for (const t of tryTypes) {
+        try {
+          await cloudinaryUpload.uploader.destroy(key, { resource_type: t });
+          ok = true;
+          break;
+        } catch {
+          // try next
+        }
+      }
+      if (ok) deleted.push(key);
+      else failed.push(key);
+    } catch {
+      failed.push(key);
+    }
+  }
+
+  for (const url of urls) {
+    try {
+      await deleteFileFromCloudinary(url);
+      deleted.push(url);
+    } catch {
+      failed.push(url);
+    }
+  }
+
+  return { deleted, failed };
+};
+
+export const mediaService = {
+  signMedia,
+  createMediaPresign,
+  deleteMediaUploads,
+};

package/modules/storage/cloudinary/files/express/modules/media/media.type.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+
+export const mediaSignSchema = z.object({
+  publicId: z.string().min(1),
+  transformation: z.string().min(1).optional(),
+});
+
+export const mediaUploadPresignSchema = z.object({
+  folder: z.string().min(1).optional(),
+  publicId: z.string().min(1).optional(),
+  resourceType: z
+    .enum(["image", "video", "raw", "auto"] as const)
+    .optional()
+    .default("auto"),
+  unsigned: z.boolean().optional().default(false),
+});
+
+export const mediaUploadDeleteSchema = z
+  .object({
+    keys: z.array(z.string().min(1)).optional(),
+    urls: z.array(z.string().min(1)).optional(),
+  })
+  .refine(
+    (value) => (value.keys?.length ?? 0) > 0 || (value.urls?.length ?? 0) > 0,
+    {
+      message: "keys or urls required",
+    },
+  );
+
+export type MediaSignInput = z.infer<typeof mediaSignSchema>;
+export type MediaUploadPresignInput = z.infer<typeof mediaUploadPresignSchema>;
+export type MediaUploadDeleteInput = z.infer<typeof mediaUploadDeleteSchema>;

package/modules/storage/cloudinary/generator.json

@@ -0,0 +1,34 @@
+{
+  "name": "cloudinary",
+  "type": "storage",
+  "priority": 5,
+  "operations": [
+    {
+      "type": "create-file",
+      "source": "express/config/*",
+      "destination": "src/config/*",
+      "condition": { "framework": "express" }
+    },
+    {
+      "type": "create-file",
+      "source": "express/modules/media/*",
+      "destination": "src/modules/media/*",
+      "condition": { "framework": "express" }
+    },
+    {
+      "type": "add-dependency",
+      "dependencies": {
+         "cloudinary": "^1.39.0"
+      }
+    },
+    {
+      "type": "add-env",
+      "envVars": {
+        "CLOUDINARY_CLOUD_NAME": "your_cloud_name",
+        "CLOUDINARY_API_KEY": "your_api_key",
+        "CLOUDINARY_API_SECRET": "your_api_secret",
+        "CLOUDINARY_UPLOAD_PRESET": "your_upload_preset"
+      }
+    }
+  ]
+}

package/modules/storage/cloudinary/module.json

@@ -0,0 +1,11 @@
+{
+  "name": "cloudinary",
+  "displayName": "Cloudinary Storage",
+  "category": "storage",
+  "description": "Cloudinary provider for uploads",
+  "supportedFrameworks": ["express"],
+  "compatibility": {
+    "frameworks": ["express"],
+    "languages": ["typescript", "javascript"]
+  }
+}

package/modules/ui/shadcn/generator.json

@@ -0,0 +1,21 @@
+{
+  "name": "shadcn",
+  "type": "ui",
+  "priority": 5,
+  "operations": [
+    {
+      "type": "run-command",
+      "command": "{{packageManager=='pnpm' ? 'pnpm dlx shadcn@latest init -t next -d -y' : packageManager=='yarn' ? 'yarn dlx shadcn@latest init -t next -d -y' : packageManager=='bun' ? 'bunx shadcn@latest init -t next -d -y' : 'npx shadcn@latest init -t next -d -y'}}",
+      "condition": { "framework": "nextjs" }
+    },
+    {
+      "type": "run-command",
+      "command": "{{packageManager=='pnpm' ? 'pnpm dlx shadcn@latest init -t vite -d -y' : packageManager=='yarn' ? 'yarn dlx shadcn@latest init -t vite -d -y' : packageManager=='bun' ? 'bunx shadcn@latest init -t vite -d -y' : 'npx shadcn@latest init -t vite -d -y'}}",
+      "condition": { "framework": "react" }
+    },
+    {
+      "type": "run-command",
+      "command": "{{packageManager=='pnpm' ? 'pnpm dlx shadcn@latest add button -y' : packageManager=='yarn' ? 'yarn dlx shadcn@latest add button -y' : packageManager=='bun' ? 'bun dlx shadcn@latest add button -y' : 'npx shadcn@latest add button -y'}}"
+    }
+  ]
+}

package/modules/ui/shadcn/module.json

@@ -0,0 +1,11 @@
+{
+  "name": "shadcn",
+  "displayName": "Shadcn UI",
+  "category": "ui",
+  "description": "Shadcn-style component set + tailwind helpers",
+  "supportedFrameworks": ["react", "nextjs"],
+  "compatibility": {
+    "frameworks": ["react", "nextjs"],
+    "languages": ["typescript", "javascript"]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stackkit",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Production-ready CLI to create and extend JavaScript or TypeScript apps with modular stacks.",
   "main": "dist/index.js",
   "bin": {
@@ -24,7 +24,8 @@
   },
   "scripts": {
     "dev": "tsc --watch",
-    "build": "npm run clean && tsc && npm run copy-assets",
+    "bundle": "node ./scripts/bundle.js",
+    "build": "npm run clean && tsc && npm run copy-assets && npm run bundle",
     "copy-assets": "node ./scripts/copy-assets.js",
     "clean": "node ./scripts/clean.js",
     "typecheck": "tsc --noEmit",
@@ -52,32 +53,29 @@
   ],
   "author": "Tariqul Islam",
   "license": "MIT",
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "chalk": "^4.1.2",
-    "commander": "^12.0.0",
-    "detect-package-manager": "^3.0.1",
-    "execa": "^5.1.1",
-    "fs-extra": "^11.2.0",
-    "inquirer": "^9.3.8",
-    "ora": "^5.4.1",
-    "validate-npm-package-name": "^5.0.1",
-    "@babel/core": "^7.28.5",
-    "@babel/preset-env": "^7.28.5",
-    "@babel/preset-typescript": "^7.28.5",
-    "@babel/preset-react": "^7.28.5",
-    "recast": "^0.20.5",
-    "@babel/parser": "^7.28.5",
-    "@babel/plugin-transform-typescript": "^7.28.5",
-    "@babel/plugin-transform-react-jsx": "^7.27.1"
-  },
   "devDependencies": {
+    "@babel/core": "^7.29.0",
+    "@babel/parser": "^7.29.2",
+    "@babel/plugin-transform-typescript": "^7.28.6",
+    "@babel/preset-env": "^7.29.2",
+    "@babel/preset-typescript": "^7.28.5",
     "@types/fs-extra": "^11.0.4",
-    "@types/inquirer": "^9.0.7",
-    "@types/node": "^25.0.8",
+    "@types/node": "^25.5.0",
+    "@types/prompts": "^2.4.9",
     "@types/validate-npm-package-name": "^4.0.2",
-    "typescript": "^5.3.3"
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "detect-package-manager": "^3.0.2",
+    "esbuild": "^0.27.4",
+    "execa": "^9.6.1",
+    "fs-extra": "^11.3.4",
+    "ora": "^9.3.0",
+    "prompts": "^2.4.2",
+    "recast": "^0.23.11",
+    "typescript": "^6.0.2",
+    "validate-npm-package-name": "^7.0.2"
+  },
+  "engines": {
+    "node": ">=18"
   }
 }

package/templates/express/README.md

@@ -1,6 +1,6 @@
-# Express Template
+# Express API
 
-Production-ready Express (TypeScript) starter for building REST APIs and backend services.
+Production-ready Express (TypeScript) starter for building REST APIs, generated by [StackKit](https://github.com/tariqul420/stackkit).
 
 ## Requirements
 
@@ -23,13 +23,15 @@ npm run dev
 
 ## Scripts
 
-- `npm run dev` - Start development server
-- `npm run build` - Build TypeScript
-- `npm start` - Start production server
+| Command      | Description              |
+| ------------ | ------------------------ |
+| `pnpm dev`   | Start development server |
+| `pnpm build` | Compile TypeScript       |
+| `pnpm start` | Start production server  |
 
 ## Environment
 
-Use a `.env` file or environment variables for configuration. See `.env.example` for available keys.
+Copy `.env.example` to `.env` and fill in your credentials. Do not commit secrets.
 
 ## Recommended Folder & File Structure
 
@@ -47,8 +49,8 @@ express-api/
 │
 │   ├── database/
 │   │   └── prisma.ts                     # PrismaClient singleton
-│   
-│   ├── lib/ 
+│
+│   ├── lib/
 │       └── auth.ts                   # Auth server config
 │
 │   ├── shared/
@@ -114,11 +116,4 @@ express-api/
 
 ---
 
-## Generated with StackKit
-
-This project was scaffolded using **StackKit** — a CLI toolkit for building production-ready applications.
-
-- Generated via: `npx stackkit@latest create`
-
-Learn more about StackKit:
-https://github.com/tariqul420/stackkit
+Generated with [StackKit](https://github.com/tariqul420/stackkit) — `npx stackkit@latest create`

package/templates/express/src/config/env.ts

@@ -8,12 +8,13 @@ dotenv.config({ path: path.join(process.cwd(), ".env") });
 interface EnvConfig {
   NODE_ENV: string;
   PORT: string;
+  APP_NAME: string;
   APP_URL: string;
   FRONTEND_URL: string;
 }
 
 const loadEnvVars = (): EnvConfig => {
-  const requiredEnvVars = ["NODE_ENV", "PORT", "APP_URL", "FRONTEND_URL"];
+  const requiredEnvVars = ["NODE_ENV", "PORT", "APP_NAME", "APP_URL", "FRONTEND_URL"];
 
   requiredEnvVars.forEach((varName) => {
     if (!process.env[varName]) {
@@ -25,10 +26,11 @@ const loadEnvVars = (): EnvConfig => {
   });
 
   return {
-    NODE_ENV: process.env.NODE_ENV as string,
-    PORT: process.env.PORT as string,
-    APP_URL: process.env.APP_URL as string,
-    FRONTEND_URL: process.env.FRONTEND_URL as string,
+    APP_NAME: process.env.APP_NAME || "App Name",
+    NODE_ENV: process.env.NODE_ENV || "development",
+    PORT: process.env.PORT || "3000",
+    APP_URL: process.env.APP_URL || "http://localhost:5000",
+    FRONTEND_URL: process.env.FRONTEND_URL || "http://localhost:3000",
   };
 };