this version brings dynamic swagger generation for crud apis for better testing and dev experience

Author: shivanshtalwar0

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@januscaler/tsed-helper",
-  "version": "2.3.3",
+  "version": "2.3.4",
   "type": "module",
   "publishConfig": {
     "@januscaler:registry": "https://npm.pkg.github.com"
@@ -18,28 +18,30 @@
     "dist/**/*"
   ],
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "prettier": "prettier --write 'src/**/*.ts' 'test/**/*.ts'"
   },
   "keywords": [],
   "author": "",
   "license": "ISC",
   "description": "",
   "devDependencies": {
-    "@types/node": "24.5.0",
-    "typescript": "5.9.2"
+    "@types/node": "25.0.9",
+    "typescript": "5.9.3"
   },
   "dependencies": {
-    "@prisma/client": "6.16.2",
-    "@prisma/internals": "6.16.2",
-    "@tsed/common": "8.16.2",
-    "@tsed/core": "8.16.2",
-    "@tsed/di": "8.16.2",
-    "@tsed/prisma": "8.16.2",
-    "@tsed/schema": "8.16.2",
-    "@types/lodash": "^4.17.20",
+    "@prisma/client": "6.19.2",
+    "@prisma/internals": "6.19.2",
+    "@tsed/common": "8.23.0",
+    "@tsed/core": "8.23.0",
+    "@tsed/di": "8.23.0",
+    "@tsed/prisma": "8.23.0",
+    "@tsed/schema": "8.23.0",
+    "@types/lodash": "^4.17.23",
     "aigle": "1.14.1",
-    "glob": "11.0.3",
+    "glob": "13.0.0",
     "lodash": "4.17.21",
+    "prettier": "^3.8.0",
     "rxjs": "7.8.2"
   }
 }

src/baseCrud.ts

@@ -1,8 +1,11 @@
 import { useDecorators } from '@tsed/core';
-import { Delete, Get, inject, Post, Put, } from '@tsed/common';
-import {  CollectionOf, Default, Example, Property, Required, Returns, Summary } from '@tsed/schema';
+import { Delete, Get, Post, Put, } from '@tsed/common';
+import { CollectionOf, Default, Enum, Example, Property, Required, Returns, Summary } from '@tsed/schema';
 import _ from 'lodash';
 import { SearchFilterRecord } from './types.js';
+import { PrismaMetaMapper } from './prismaMetaMapper.js';
+import aigle from 'aigle';
+const { Aigle } = aigle;
 
 function nameWithoutModel(model: any): string {
 	return _.replace(model.name, 'Model', '');
@@ -98,3 +101,142 @@ export function getItems(options: GetItems): Function {
 			.Description(`Return a list of ${nameWithoutModel(model)}`)
 	);
 }
+
+
+
+
+export type FilterMode =
+	| "EM"
+	| "EQ"
+	| "EX"
+	| "LT"
+	| "LTE"
+	| "GT"
+	| "GTE"
+	| "NEM"
+	| "RG";
+
+export const FilterModeEnum: FilterMode[] = [
+	"EM", "EQ", "EX", "LT", "LTE", "GT", "GTE", "NEM", "RG"
+];
+
+// Typed filter record
+export type SearchFilter<TFields extends string> = {
+	[K in TFields]: {
+		mode: FilterMode;
+		value: any;
+		isRelation?: boolean;
+	};
+};
+
+export class BaseSearchParams {
+	@Default(10)
+	limit?: number;
+
+	@Default(0)
+	offset?: number;
+}
+
+export class FilterItemModel {
+	@Enum(FilterModeEnum)
+	mode!: FilterMode;
+	@Property()
+	value!: any;
+	@Property()
+	isRelation?: boolean;
+}
+
+export async function makeSearchParamsForPrismaModel<TField extends string>(model: string) {
+	const entityFieldMapping = await PrismaMetaMapper.getEntityFieldMapping(PrismaMetaMapper.normalizeEntityName(model));
+	const scalarExamples = _.transform(entityFieldMapping, (result, value, key) => {
+		if (!value.isList && !value.relationName) {
+			result.push(key as TField);
+		}
+	}, [] as TField[]);
+	const relationExamples = await Aigle.transform(entityFieldMapping, async (result, value, key) => {
+		if (value.isList || value.relationName) {
+			const relationFieldMapping = await PrismaMetaMapper.getEntityFieldMapping(PrismaMetaMapper.normalizeEntityName(value.type));
+			for (const [relationFieldName, relationField] of Object.entries(relationFieldMapping)) {
+				if (!relationField.isList && !relationField.relationName) {
+					result.push(`${key}.${relationFieldName}` as TField);
+				}
+			}
+		}
+	}, [] as TField[]);
+	return makeSearchParamsFor<TField>([...scalarExamples, ...relationExamples], entityFieldMapping);
+}
+
+function getPrismaExample(fieldInfo: { type: string; isArray?: boolean }) {
+	let example: any;
+
+	switch (fieldInfo.type) {
+		case "String":
+			example = "example";
+			break;
+		case "Int":
+			example = 123;
+			break;
+		case "BigInt":
+			example = 123n;
+			break;
+		case "Float":
+			example = 12.34;
+			break;
+		case "Decimal":
+			example = "12.34"; // Prisma Decimal is a string
+			break;
+		case "Boolean":
+			example = true;
+			break;
+		case "DateTime":
+			example = new Date().toISOString();
+			break;
+		case "Json":
+			example = { key: "value" };
+			break;
+		case "Bytes":
+			example = "AA=="; // base64 string
+			break;
+		default:
+			example = "example";
+	}
+
+	if (fieldInfo.isArray) {
+		return [example];
+	}
+
+	return example;
+}
+
+export function makeSearchParamsFor<TField extends string>(examples: TField[], entityFieldMapping?: Record<string, any>) {
+	const filterExample = [
+		examples.reduce((acc, f) => {
+			if (!f.includes('.')) {
+				const fieldInfo = entityFieldMapping ? entityFieldMapping[f] : null;
+				acc[f] = { mode: "EQ", value: getPrismaExample(fieldInfo) };
+			}
+			return acc;
+		}, {} as Record<TField, any>)
+	]
+	const orderByExample = examples.reduce((acc, f) => {
+		if (!f.includes('.')) {
+			acc[f] = "asc";
+		}
+		return acc;
+	}, {} as Record<TField, "asc" | "desc">);
+	class DynamicSearchParams extends BaseSearchParams {
+		@Example(examples)
+		@Required(true)
+		@CollectionOf(String)
+		fields!: TField[];
+		@Example(orderByExample)
+		@CollectionOf(Object)
+		orderBy: Record<TField, "asc" | "desc">;
+		@Property()
+		@CollectionOf(Object)
+		@Example(filterExample)
+		filters: SearchFilter<TField>[];
+	}
+
+	return DynamicSearchParams;
+}

src/baseService.ts

@@ -98,8 +98,8 @@ export class BaseService<T, M> implements OnInit, IBaseService<M> {
 
 
 	async $onInit(): Promise<any> {
-		const prismaMapper = new PrismaMetaMapper(this.prismaFilePath)
-		this.tablesInfo = await prismaMapper.getTablesInfo()
+		PrismaMetaMapper.relativePrismaFilePath = this.prismaFilePath
+		this.tablesInfo = await PrismaMetaMapper.getTablesInfo()
 	}
 
 	/**
@@ -379,7 +379,7 @@ export class BaseService<T, M> implements OnInit, IBaseService<M> {
 		const properties = {
 			skip: offset,
 			take: limit,
-			orderBy: orderBy,
+			orderBy: _.map(orderBy, (value, key) => ({ [key]: value })),
 			where: prismaWhere,
 			select: selectFields
 		};

src/prismaMetaMapper.ts

@@ -1,12 +1,7 @@
 import _ from 'lodash';
 import pi from '@prisma/internals';
-import { join, dirname } from 'path'
 import { DMMF, ReadonlyDeep } from '@prisma/client/runtime/library';
-import { fileURLToPath } from 'url';
 import { readFile } from 'fs/promises';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
 const { getDMMF } = pi
 
 export interface PrismaMapperEntity {
@@ -46,32 +41,36 @@ export interface PrismaMapperEntityField {
 
 export class PrismaMetaMapper {
 
-    constructor(protected relativePrismaFilePath = "./prisma/schema.prisma") { }
+    static relativePrismaFilePath: string = "./prisma/schema.prisma"
+
+    static normalizeEntityName(entityName: string) {
+        return _.upperFirst(_.camelCase(_.split(entityName, 'Model')[0])) as string
+    }
 
-    async getDMMF(): Promise<ReadonlyDeep<{
+    static async getDMMF(overrideRelativePrismaFilePath?: string): Promise<ReadonlyDeep<{
         datamodel: DMMF.Datamodel;
         schema: DMMF.Schema;
         mappings: DMMF.Mappings;
     }>> {
         const dmmf = await getDMMF({
-            datamodel: await readFile(this.relativePrismaFilePath, 'utf-8')
+            datamodel: await readFile(overrideRelativePrismaFilePath ?? this.relativePrismaFilePath, 'utf-8')
         })
         return dmmf
     }
 
-    async getEntity(entityName: string) {
+    static async getEntity(entityName: string) {
         const tablesInfo = await this.getTablesInfo()
         return tablesInfo[entityName]
     }
 
-    async getEntityFieldMapping(entityName: string) {
+    static async getEntityFieldMapping(entityName: string) {
         const { fields } = await this.getEntity(entityName)
         return _.transform(fields, (result, field) => {
             result[field.name] = field;
         }, {}) as Promise<Record<string, PrismaMapperEntityField>>
     }
 
-    async getTablesInfo() {
+    static async getTablesInfo() {
         const dmmf = await this.getDMMF()
         return _.transform(dmmf.datamodel.models, (finalInfoMap, value) => {
             finalInfoMap[value.name] = value

src/seederHelper.ts

@@ -3,6 +3,7 @@ import aigle from 'aigle'
 import { sync } from 'glob'
 import { join, basename, dirname } from 'path'
 import { fileURLToPath } from 'url';
+import { PrismaMetaMapper } from './prismaMetaMapper.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const { Aigle } = aigle
@@ -21,8 +22,8 @@ export class SeederHelper {
         }, {})
     }
 
-    async generatePrismaCreateUpdatePayload({ rowData, metaMapper, entity, prismaService }) {
-        const entityFieldMapping = await metaMapper.getEntityFieldMapping(entity);
+    async generatePrismaCreateUpdatePayload({ rowData, entity, prismaService }) {
+        const entityFieldMapping = await PrismaMetaMapper.getEntityFieldMapping(entity);
         return Aigle.transform(rowData, async (createPayload, value, column: string) => {
             if (entityFieldMapping[column]?.relationName) {
                 const targetColumnEntityName = _.lowerFirst(entityFieldMapping[column].type)