@asad_dev/leo-generator 1.6.0

package/dist/templates/controller.template.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateControllerContent = void 0;
+const generateControllerContent = (camelCaseName, folderName, fields) => {
+    // Check if there are any file/image fields
+    const hasImageField = fields.some((field) => field.name === "image" || field.name === "images" || field.name === "media" || field.type.toLowerCase() === "image");
+    // Generate filterable fields (string and enum types)
+    const filterableFields = fields.filter(f => f.type.toLowerCase() === "string" || f.type.toLowerCase() === "enum");
+    return `import { Request, Response } from 'express';
+import { ${camelCaseName}Services } from './${folderName}.service';
+import catchAsync from '../../../shared/catchAsync';
+import sendResponse from '../../../shared/sendResponse';
+import { StatusCodes } from 'http-status-codes';
+import pick from '../../../shared/pick';
+import { ${folderName}Filterables } from './${folderName}.constants';
+import { paginationFields } from '../../../interfaces/pagination';
+
+const create${camelCaseName} = catchAsync(async (req: Request, res: Response) => {
+  ${hasImageField
+        ? `const { images, media, ...${folderName}Data } = req.body;
+  
+  if (images && images.length > 0) {
+    ${folderName}Data.images = images;
+  }
+  
+  if (media && media.length > 0) {
+    ${folderName}Data.media = media;
+  }`
+        : `const ${folderName}Data = req.body;`}
+
+  const result = await ${camelCaseName}Services.create${camelCaseName}(
+    req.user!,
+    ${folderName}Data
+  );
+
+  sendResponse(res, {
+    statusCode: StatusCodes.CREATED,
+    success: true,
+    message: '${camelCaseName} created successfully',
+    data: result,
+  });
+});
+
+const update${camelCaseName} = catchAsync(async (req: Request, res: Response) => {
+  const { id } = req.params;
+  const ${folderName}Data = req.body;
+
+  const result = await ${camelCaseName}Services.update${camelCaseName}(id, ${folderName}Data);
+
+  sendResponse(res, {
+    statusCode: StatusCodes.OK,
+    success: true,
+    message: '${camelCaseName} updated successfully',
+    data: result,
+  });
+});
+
+const getSingle${camelCaseName} = catchAsync(async (req: Request, res: Response) => {
+  const { id } = req.params;
+  const result = await ${camelCaseName}Services.getSingle${camelCaseName}(id);
+
+  sendResponse(res, {
+    statusCode: StatusCodes.OK,
+    success: true,
+    message: '${camelCaseName} retrieved successfully',
+    data: result,
+  });
+});
+
+const getAll${camelCaseName}s = catchAsync(async (req: Request, res: Response) => {
+  const filterables = pick(req.query, ${folderName}Filterables);
+  const pagination = pick(req.query, paginationFields);
+
+  const result = await ${camelCaseName}Services.getAll${camelCaseName}s(
+    req.user!,
+    filterables,
+    pagination
+  );
+
+  sendResponse(res, {
+    statusCode: StatusCodes.OK,
+    success: true,
+    message: '${camelCaseName}s retrieved successfully',
+    data: result,
+  });
+});
+
+const delete${camelCaseName} = catchAsync(async (req: Request, res: Response) => {
+  const { id } = req.params;
+  const result = await ${camelCaseName}Services.delete${camelCaseName}(id);
+
+  sendResponse(res, {
+    statusCode: StatusCodes.OK,
+    success: true,
+    message: '${camelCaseName} deleted successfully',
+    data: result,
+  });
+});
+
+export const ${camelCaseName}Controller = {
+  create${camelCaseName},
+  update${camelCaseName},
+  getSingle${camelCaseName},
+  getAll${camelCaseName}s,
+  delete${camelCaseName},
+};`;
+};
+exports.generateControllerContent = generateControllerContent;

package/dist/templates/route.template.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRouteContent = void 0;
+const generateRouteContent = (camelCaseName, folderName, fields) => {
+    // Check if there are any file/image fields
+    const hasImageField = fields.some((field) => field.name === "image" || field.name === "images" || field.name === "media" || field.type.toLowerCase() === "image");
+    return `import express from 'express';
+import { ${camelCaseName}Controller } from './${folderName}.controller';
+import { ${camelCaseName}Validations } from './${folderName}.validation';
+import validateRequest from '../../middleware/validateRequest';
+import auth from '../../middleware/auth';
+import { USER_ROLES } from '../../../enum/user';
+${hasImageField ? `import { fileAndBodyProcessorUsingDiskStorage } from '../../middleware/processReqBody';` : ""}
+
+const router = express.Router();
+
+router.get(
+  '/',
+  auth(
+    USER_ROLES.SUPER_ADMIN,
+    USER_ROLES.ADMIN
+  ),
+  ${camelCaseName}Controller.getAll${camelCaseName}s
+);
+
+router.get(
+  '/:id',
+  auth(
+    USER_ROLES.SUPER_ADMIN,
+    USER_ROLES.ADMIN
+  ),
+  ${camelCaseName}Controller.getSingle${camelCaseName}
+);
+
+router.post(
+  '/',
+  auth(
+    USER_ROLES.SUPER_ADMIN,
+    USER_ROLES.ADMIN
+  ),
+  ${hasImageField ? `fileAndBodyProcessorUsingDiskStorage(),` : ""}
+  validateRequest(${camelCaseName}Validations.create${camelCaseName}ZodSchema),
+  ${camelCaseName}Controller.create${camelCaseName}
+);
+
+router.patch(
+  '/:id',
+  auth(
+    USER_ROLES.SUPER_ADMIN,
+    USER_ROLES.ADMIN
+  ),
+  ${hasImageField ? `fileAndBodyProcessorUsingDiskStorage(),` : ""}
+  validateRequest(${camelCaseName}Validations.update${camelCaseName}ZodSchema),
+  ${camelCaseName}Controller.update${camelCaseName}
+);
+
+router.delete(
+  '/:id',
+  auth(
+    USER_ROLES.SUPER_ADMIN,
+    USER_ROLES.ADMIN
+  ),
+  ${camelCaseName}Controller.delete${camelCaseName}
+);
+
+export const ${camelCaseName}Routes = router;`;
+};
+exports.generateRouteContent = generateRouteContent;

package/dist/templates/service.template.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateServiceContent = void 0;
+const generateServiceContent = (camelCaseName, folderName, fields, hasFile = false) => {
+    // Check if there are any file/image fields or if hasFile flag is true
+    const hasImageField = hasFile || fields.some((field) => field.name === "image" || field.name === "images" || field.name === "media" || field.type.toLowerCase() === "image");
+    // Check for reference fields for population
+    const referenceFields = fields.filter((field) => {
+        var _a;
+        return field.type.toLowerCase() === "objectid" ||
+            (field.type.toLowerCase() === "array" && ((_a = field.arrayItemType) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === "objectid");
+    });
+    const populateString = referenceFields.length > 0
+        ? `.populate('${referenceFields.map(f => f.name).join("').populate('")}')`
+        : "";
+    // Generate filterable fields (string and enum types)
+    const filterableFields = fields.filter(f => f.type.toLowerCase() === "string" || f.type.toLowerCase() === "enum");
+    // Generate searchable fields (string types only)
+    const searchableFields = fields.filter(f => f.type.toLowerCase() === "string");
+    return `import { StatusCodes } from 'http-status-codes';
+import ApiError from '../../../errors/ApiError';
+import { I${camelCaseName}Filterables, I${camelCaseName} } from './${folderName}.interface';
+import { ${camelCaseName} } from './${folderName}.model';
+import { JwtPayload } from 'jsonwebtoken';
+import { IPaginationOptions } from '../../../interfaces/pagination';
+import { paginationHelper } from '../../../helpers/paginationHelper';
+import { ${folderName}SearchableFields } from './${folderName}.constants';
+import { Types } from 'mongoose';
+${hasImageField
+        ? `import removeFile from '../../../helpers/fileHelper';`
+        : ""}
+
+const create${camelCaseName} = async (
+  user: JwtPayload,
+  payload: I${camelCaseName}
+): Promise<I${camelCaseName}> => {
+  try {
+    const result = await ${camelCaseName}.create(payload);
+    if (!result) {
+      ${hasImageField ? `await removeFile(payload.images || payload.media);` : ""}
+      throw new ApiError(
+        StatusCodes.BAD_REQUEST,
+        'Failed to create ${camelCaseName}, please try again with valid data.'
+      );
+    }
+
+    return result;
+  } catch (error: any) {
+    ${hasImageField ? `if (payload.images || payload.media) await removeFile(payload.images || payload.media);` : ""}
+    if (error.code === 11000) {
+      throw new ApiError(StatusCodes.CONFLICT, 'Duplicate entry found');
+    }
+    throw error;
+  }
+};
+
+const getAll${camelCaseName}s = async (
+  user: JwtPayload,
+  filterables: I${camelCaseName}Filterables,
+  pagination: IPaginationOptions
+) => {
+  const { searchTerm, ...filterData } = filterables;
+  const { page, skip, limit, sortBy, sortOrder } = paginationHelper.calculatePagination(pagination);
+
+  const andConditions = [];
+
+  // Search functionality
+  if (searchTerm) {
+    andConditions.push({
+      $or: ${folderName}SearchableFields.map((field) => ({
+        [field]: {
+          $regex: searchTerm,
+          $options: 'i',
+        },
+      })),
+    });
+  }
+
+  // Filter functionality
+  if (Object.keys(filterData).length) {
+    andConditions.push({
+      $and: Object.entries(filterData).map(([key, value]) => ({
+        [key]: value,
+      })),
+    });
+  }
+
+  const whereConditions = andConditions.length ? { $and: andConditions } : {};
+
+  const [result, total] = await Promise.all([
+    ${camelCaseName}
+      .find(whereConditions)
+      .skip(skip)
+      .limit(limit)
+      .sort({ [sortBy]: sortOrder })${populateString},
+    ${camelCaseName}.countDocuments(whereConditions),
+  ]);
+
+  return {
+    meta: {
+      page,
+      limit,
+      total,
+      totalPages: Math.ceil(total / limit),
+    },
+    data: result,
+  };
+};
+
+const getSingle${camelCaseName} = async (id: string): Promise<I${camelCaseName}> => {
+  if (!Types.ObjectId.isValid(id)) {
+    throw new ApiError(StatusCodes.BAD_REQUEST, 'Invalid ${camelCaseName} ID');
+  }
+
+  const result = await ${camelCaseName}.findById(id)${populateString};
+  if (!result) {
+    throw new ApiError(
+      StatusCodes.NOT_FOUND,
+      'Requested ${folderName} not found, please try again with valid id'
+    );
+  }
+
+  return result;
+};
+
+const update${camelCaseName} = async (
+  id: string,
+  payload: Partial<I${camelCaseName}>
+): Promise<I${camelCaseName} | null> => {
+  if (!Types.ObjectId.isValid(id)) {
+    throw new ApiError(StatusCodes.BAD_REQUEST, 'Invalid ${camelCaseName} ID');
+  }
+
+  const result = await ${camelCaseName}.findByIdAndUpdate(
+    new Types.ObjectId(id),
+    { $set: payload },
+    {
+      new: true,
+      runValidators: true,
+    }
+  )${populateString};
+
+  if (!result) {
+    throw new ApiError(
+      StatusCodes.NOT_FOUND,
+      'Requested ${folderName} not found, please try again with valid id'
+    );
+  }
+
+  return result;
+};
+
+const delete${camelCaseName} = async (id: string): Promise<I${camelCaseName}> => {
+  if (!Types.ObjectId.isValid(id)) {
+    throw new ApiError(StatusCodes.BAD_REQUEST, 'Invalid ${camelCaseName} ID');
+  }
+
+  const result = await ${camelCaseName}.findByIdAndDelete(id);
+  if (!result) {
+    throw new ApiError(
+      StatusCodes.NOT_FOUND,
+      'Something went wrong while deleting ${folderName}, please try again with valid id.'
+    );
+  }
+
+  ${hasImageField
+        ? `// Remove associated files
+  if (result.image || result.images || result.media) {
+    await removeFile(result.image || result.images || result.media);
+  }`
+        : ""}
+
+  return result;
+};
+
+export const ${camelCaseName}Services = {
+  create${camelCaseName},
+  getAll${camelCaseName}s,
+  getSingle${camelCaseName},
+  update${camelCaseName},
+  delete${camelCaseName},
+};`;
+};
+exports.generateServiceContent = generateServiceContent;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });