@nest-extended/cli 0.0.2-beta-13 → 0.0.2-beta-15

package/src/templates/prisma-auth.template.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * Prisma-compatible auth templates.
+ * Same functionality as the Mongoose auth templates but using Prisma.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrismaJwtConstants = exports.getPrismaAuthGuard = exports.getPrismaAuthModule = exports.getPrismaAuthService = exports.getPrismaAuthController = void 0;
+const getPrismaAuthController = () => `import {
+  Body,
+  Controller,
+  Post,
+  HttpCode,
+  HttpStatus,
+  Get,
+  Request,
+  BadRequestException,
+} from '@nestjs/common';
+import { AuthService } from './auth.service';
+import { Public } from '@nest-extended/decorators';
+import { UsersService } from '../users/users.service';
+
+@Controller('authentication')
+export class AuthController {
+  constructor(
+    private authService: AuthService,
+    private usersService: UsersService,
+  ) {}
+
+  @Public()
+  @HttpCode(HttpStatus.OK)
+  @Post('')
+  signIn(@Body() signInDto: Record<string, string>) {
+    if (signInDto.strategy === 'local') {
+      return this.authService.signInLocal(signInDto.email, signInDto.password);
+    }
+    throw new BadRequestException('Invalid Strategy');
+  }
+
+  @Get('verify')
+  getProfile(@Request() req: Record<string, any>) {
+    const user = req.user as Record<string, any>;
+    return {
+      user: this.usersService.sanitizeUser(user),
+    };
+  }
+}
+`;
+exports.getPrismaAuthController = getPrismaAuthController;
+const getPrismaAuthService = () => `import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import * as bcrypt from 'bcrypt';
+import { UsersService } from '../users/users.service';
+
+@Injectable()
+export class AuthService {
+  constructor(
+    private usersService: UsersService,
+    private jwtService: JwtService,
+  ) { }
+
+  async signInLocal(
+    email: string,
+    pass: string,
+  ): Promise<Record<string, unknown>> {
+    const users = await this.usersService._find(
+      {
+        email,
+        $limit: 1,
+        $select: ['id', 'firstName', 'lastName', 'email', 'password', 'createdAt', 'updatedAt'],
+      },
+      { pagination: false },
+    );
+
+    const user = users[0] as Record<string, any>;
+    if (!user) throw new UnauthorizedException();
+
+    const passwordValid = await bcrypt.compare(pass, user.password);
+    if (!passwordValid) {
+      throw new UnauthorizedException();
+    }
+
+    const sanitizedUser = this.usersService.sanitizeUser(user);
+    const payload = { sub: { id: user.id }, user };
+    return {
+      accessToken: await this.jwtService.signAsync(payload),
+      user: sanitizedUser,
+    };
+  }
+}
+`;
+exports.getPrismaAuthService = getPrismaAuthService;
+const getPrismaAuthModule = () => `import { Module } from '@nestjs/common';
+import { AuthService } from './auth.service';
+import { JwtModule } from '@nestjs/jwt';
+import { AuthController } from './auth.controller';
+import { APP_GUARD } from '@nestjs/core';
+import { AuthGuard } from './auth.guard';
+import { UsersModule } from '../users/users.module';
+import { jwtConstants } from './constants/jwt-constants';
+
+@Module({
+  imports: [
+    UsersModule,
+    JwtModule.register({
+      global: true,
+      secret: jwtConstants.secret,
+      signOptions: { expiresIn: '365d' },
+    }),
+  ],
+  providers: [
+    AuthService,
+    {
+      provide: APP_GUARD,
+      useClass: AuthGuard,
+    },
+  ],
+  controllers: [AuthController],
+  exports: [AuthService],
+})
+export class AuthModule {}
+`;
+exports.getPrismaAuthModule = getPrismaAuthModule;
+const getPrismaAuthGuard = () => `import {
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { JwtService } from '@nestjs/jwt';
+import { IS_PUBLIC_KEY } from '@nest-extended/decorators';
+import { UsersService } from '../users/users.service';
+import { jwtConstants } from './constants/jwt-constants';
+import { ClsService } from 'nestjs-cls';
+
+@Injectable()
+export class AuthGuard implements CanActivate {
+  constructor(
+    private usersService: UsersService,
+    private jwtService: JwtService,
+    private reflector: Reflector,
+    private cls: ClsService,
+  ) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+    if (isPublic) {
+      return true;
+    }
+    const request = context.switchToHttp().getRequest<{ user?: Record<string, unknown>, headers: Record<string, string | undefined> }>();
+    const token = this.extractTokenFromHeader(request);
+    if (!token) {
+      throw new UnauthorizedException();
+    }
+    try {
+      const payload = await this.jwtService.verifyAsync<{ sub: { id: string } }>(token, {
+        secret: jwtConstants.secret,
+      });
+       const user = (await this.usersService._get(
+        payload.sub.id,
+      )) as unknown as Record<string, unknown>;
+      if (user) {
+        request.user = user;
+        this.cls.set('user', user);
+        return true;
+      }
+    } catch {
+      throw new UnauthorizedException();
+    }
+    throw new UnauthorizedException();
+  }
+
+  private extractTokenFromHeader(request: { headers: Record<string, string | undefined> }): string | undefined {
+    const [type, token] = request.headers.authorization?.split(' ') ?? [];
+    return type === 'Bearer' ? token : undefined;
+  }
+}
+`;
+exports.getPrismaAuthGuard = getPrismaAuthGuard;
+const getPrismaJwtConstants = () => `import { randomBytes } from 'crypto';
+// NOTE: For a real application, consider using a more secure way to inject the secret (like ConfigService)
+export const jwtConstants = {
+  secret: process.env.JWT_SECRET || randomBytes(32).toString('hex'),
+};
+`;
+exports.getPrismaJwtConstants = getPrismaJwtConstants;
+//# sourceMappingURL=prisma-auth.template.js.map

package/src/templates/prisma-auth.template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma-auth.template.js","sourceRoot":"","sources":["../../../../../packages/cli/src/templates/prisma-auth.template.ts"],"names":[],"mappings":";AACA;;;GAGG;;;AAEI,MAAM,uBAAuB,GAAG,GAAW,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCpD,CAAC;AAvCW,QAAA,uBAAuB,2BAuClC;AAEK,MAAM,oBAAoB,GAAG,GAAW,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCjD,CAAC;AAzCW,QAAA,oBAAoB,wBAyC/B;AAEK,MAAM,mBAAmB,GAAG,GAAW,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BhD,CAAC;AA7BW,QAAA,mBAAmB,uBA6B9B;AAEK,MAAM,kBAAkB,GAAG,GAAW,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0D/C,CAAC;AA1DW,QAAA,kBAAkB,sBA0D7B;AAEK,MAAM,qBAAqB,GAAG,GAAW,EAAE,CAAC;;;;;CAKlD,CAAC;AALW,QAAA,qBAAqB,yBAKhC"}

package/src/templates/prisma-controller.template.d.ts

@@ -0,0 +1 @@
+export declare const getPrismaController: (Name: string, name: string, url: string) => string;

package/src/templates/prisma-controller.template.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrismaController = void 0;
+const getPrismaController = (Name, name, url) => `import {
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Patch,
+  Post,
+  Query,
+} from '@nestjs/common';
+import { ${Name}Service } from './${name}.service';
+import { User, ModifyBody, setCreatedBy } from '@nest-extended/decorators';
+
+@Controller('${url}')
+export class ${Name}Controller {
+  constructor(private readonly ${name}Service: ${Name}Service) { }
+
+  @Get()
+  async find(@Query() query: Record<string, any>) {
+    return await this.${name}Service._find(query);
+  }
+
+  @Get('/:id')
+  async get(@Query() query: Record<string, any>, @Param('id') id: string) {
+    return await this.${name}Service._get(id, query);
+  }
+
+  @Post()
+  async create(
+    @ModifyBody(setCreatedBy()) create${Name}Dto: any
+  ) {
+    return await this.${name}Service._create(create${Name}Dto);
+  }
+
+  @Patch('/:id')
+  async patch(
+    @Query() query: Record<string, any>,
+    @ModifyBody(setCreatedBy('updatedBy')) patch${Name}Dto: any,
+    @Param('id') id: string,
+  ) {
+    return await this.${name}Service._patch(id, patch${Name}Dto, query);
+  }
+
+  @Delete('/:id')
+  async delete(@Param('id') id: string, @Query() query: Record<string, any>, @User() user: Record<string, unknown>) {
+    return await this.${name}Service._remove(id, query, user);
+  }
+}
+`;
+exports.getPrismaController = getPrismaController;
+//# sourceMappingURL=prisma-controller.template.js.map

package/src/templates/prisma-controller.template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma-controller.template.js","sourceRoot":"","sources":["../../../../../packages/cli/src/templates/prisma-controller.template.ts"],"names":[],"mappings":";;;AACO,MAAM,mBAAmB,GAAG,CAAC,IAAY,EAAE,IAAY,EAAE,GAAW,EAAU,EAAE,CAAC;;;;;;;;;WAS7E,IAAI,qBAAqB,IAAI;;;eAGzB,GAAG;eACH,IAAI;iCACc,IAAI,YAAY,IAAI;;;;wBAI7B,IAAI;;;;;wBAKJ,IAAI;;;;;wCAKY,IAAI;;wBAEpB,IAAI,yBAAyB,IAAI;;;;;;kDAMP,IAAI;;;wBAG9B,IAAI,2BAA2B,IAAI;;;;;wBAKnC,IAAI;;;CAG3B,CAAC;AA/CW,QAAA,mBAAmB,uBA+C9B"}

package/src/templates/prisma-dto-class-validator.template.d.ts

@@ -0,0 +1 @@
+export declare const getPrismaDtoClassValidator: (Name: string) => string;

package/src/templates/prisma-dto-class-validator.template.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrismaDtoClassValidator = void 0;
+const getPrismaDtoClassValidator = (Name) => `import { IsString, IsOptional, IsBoolean, IsDate } from 'class-validator';
+import { Type } from 'class-transformer';
+
+/**
+ * Usage: To enable class-validator validation, add the following to your main.ts:
+ *
+ *   import { ValidationPipe } from '@nestjs/common';
+ *   app.useGlobalPipes(new ValidationPipe({ transform: true, whitelist: true }));
+ *
+ * Or apply per-route using @UsePipes(new ValidationPipe({ transform: true }))
+ */
+
+export class Create${Name}Dto {
+  @IsString()
+  @IsOptional()
+  name?: string;
+
+  @IsString()
+  @IsOptional()
+  createdBy?: string;
+
+  @IsDate()
+  @IsOptional()
+  @Type(() => Date)
+  createdAt?: Date;
+
+  @IsDate()
+  @IsOptional()
+  @Type(() => Date)
+  updatedAt?: Date;
+
+  @IsBoolean()
+  @IsOptional()
+  deleted?: boolean;
+
+  @IsString()
+  @IsOptional()
+  deletedBy?: string;
+
+  @IsDate()
+  @IsOptional()
+  @Type(() => Date)
+  deletedAt?: Date;
+}
+
+export class Patch${Name}Dto {
+  @IsString()
+  @IsOptional()
+  name?: string;
+
+  @IsDate()
+  @IsOptional()
+  @Type(() => Date)
+  updatedAt?: Date;
+
+  @IsDate()
+  @IsOptional()
+  @Type(() => Date)
+  createdAt?: Date;
+
+  @IsBoolean()
+  @IsOptional()
+  deleted?: boolean;
+
+  @IsString()
+  @IsOptional()
+  deletedBy?: string;
+
+  @IsDate()
+  @IsOptional()
+  @Type(() => Date)
+  deletedAt?: Date;
+}
+
+export class Remove${Name}Dto {
+  @IsString()
+  id: string;
+
+  @IsString()
+  @IsOptional()
+  deletedBy?: string;
+
+  @IsDate()
+  @IsOptional()
+  @Type(() => Date)
+  deletedAt?: Date;
+}
+`;
+exports.getPrismaDtoClassValidator = getPrismaDtoClassValidator;
+//# sourceMappingURL=prisma-dto-class-validator.template.js.map

package/src/templates/prisma-dto-class-validator.template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma-dto-class-validator.template.js","sourceRoot":"","sources":["../../../../../packages/cli/src/templates/prisma-dto-class-validator.template.ts"],"names":[],"mappings":";;;AACO,MAAM,0BAA0B,GAAG,CAAC,IAAY,EAAU,EAAE,CAAC;;;;;;;;;;;;qBAY/C,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAiCL,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6BH,IAAI;;;;;;;;;;;;;CAaxB,CAAC;AAvFW,QAAA,0BAA0B,8BAuFrC"}

package/src/templates/prisma-dto.template.d.ts

@@ -0,0 +1 @@
+export declare const getPrismaDto: (Name: string) => string;

package/src/templates/prisma-dto.template.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrismaDto = void 0;
+const getPrismaDto = (Name) => `import { z } from 'zod';
+
+/**
+ * Usage: To enable Zod validation, create a ZodValidationPipe and apply it globally or per-route.
+ *
+ *   // zod-validation.pipe.ts
+ *   import { PipeTransform, BadRequestException } from '@nestjs/common';
+ *   import { ZodSchema } from 'zod';
+ *   export class ZodValidationPipe implements PipeTransform {
+ *     constructor(private schema: ZodSchema) {}
+ *     transform(value: unknown) {
+ *       const result = this.schema.safeParse(value);
+ *       if (!result.success) throw new BadRequestException(result.error);
+ *       return result.data;
+ *     }
+ *   }
+ *
+ *   // Then in your controller:
+ *   @UsePipes(new ZodValidationPipe(Create${Name}Validation))
+ */
+
+export const Create${Name}Validation = z.object({
+  name: z.string().optional(),
+  createdBy: z.string().optional(),
+  createdAt: z.date().optional(),
+  updatedAt: z.date().optional(),
+  deleted: z.boolean().optional().default(false),
+  deletedBy: z.string().optional(),
+  deletedAt: z.date().optional(),
+});
+
+export const Patch${Name}Validation = z.object({
+  name: z.string().optional(),
+  updatedAt: z.date().optional(),
+  createdAt: z.date().optional(),
+  deleted: z.boolean().optional(),
+  deletedBy: z.string().optional(),
+  deletedAt: z.date().optional(),
+});
+
+export const Remove${Name}Validation = z.object({
+  id: z.string(),
+  deletedBy: z.string().optional(),
+  deletedAt: z.date().optional(),
+});
+
+export type Create${Name}DTO = z.infer<typeof Create${Name}Validation>;
+export type Patch${Name}DTO = z.infer<typeof Patch${Name}Validation>;
+export type Remove${Name}DTO = z.infer<typeof Remove${Name}Validation>;
+`;
+exports.getPrismaDto = getPrismaDto;
+//# sourceMappingURL=prisma-dto.template.js.map

package/src/templates/prisma-dto.template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma-dto.template.js","sourceRoot":"","sources":["../../../../../packages/cli/src/templates/prisma-dto.template.ts"],"names":[],"mappings":";;;AACO,MAAM,YAAY,GAAG,CAAC,IAAY,EAAU,EAAE,CAAC;;;;;;;;;;;;;;;;;;6CAkBT,IAAI;;;qBAG5B,IAAI;;;;;;;;;;oBAUL,IAAI;;;;;;;;;qBASH,IAAI;;;;;;oBAML,IAAI,8BAA8B,IAAI;mBACvC,IAAI,6BAA6B,IAAI;oBACpC,IAAI,8BAA8B,IAAI;CACzD,CAAC;AAjDW,QAAA,YAAY,gBAiDvB"}

package/src/templates/prisma-model.template.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generates a Prisma model block to append to schema.prisma.
+ *
+ * @param Name - PascalCase model name
+ * @param isAuthGenerated - Whether auth module exists (adds createdBy/updatedBy/deletedBy)
+ */
+export declare const getPrismaModel: (Name: string, isAuthGenerated?: boolean) => string;

package/src/templates/prisma-model.template.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrismaModel = void 0;
+/**
+ * Generates a Prisma model block to append to schema.prisma.
+ *
+ * @param Name - PascalCase model name
+ * @param isAuthGenerated - Whether auth module exists (adds createdBy/updatedBy/deletedBy)
+ */
+const getPrismaModel = (Name, isAuthGenerated = true) => {
+    const authFields = isAuthGenerated ? `
+  createdBy String?
+  updatedBy String?
+  deletedBy String?` : '';
+    return `
+model ${Name} {
+  id        String    @id @default(cuid())
+  name      String?
+  deleted   Boolean?  @default(false)
+  deletedAt DateTime?${authFields}
+  createdAt DateTime  @default(now())
+  updatedAt DateTime  @updatedAt
+}
+`;
+};
+exports.getPrismaModel = getPrismaModel;
+//# sourceMappingURL=prisma-model.template.js.map

package/src/templates/prisma-model.template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma-model.template.js","sourceRoot":"","sources":["../../../../../packages/cli/src/templates/prisma-model.template.ts"],"names":[],"mappings":";;;AACA;;;;;GAKG;AACI,MAAM,cAAc,GAAG,CAAC,IAAY,EAAE,kBAA2B,IAAI,EAAU,EAAE;IACpF,MAAM,UAAU,GAAG,eAAe,CAAC,CAAC,CAAC;;;oBAGrB,CAAC,CAAC,CAAC,EAAE,CAAC;IAEtB,OAAO;QACH,IAAI;;;;uBAIW,UAAU;;;;CAIhC,CAAC;AACF,CAAC,CAAC;AAhBW,QAAA,cAAc,kBAgBzB"}

package/src/templates/prisma-module.template.d.ts

@@ -0,0 +1 @@
+export declare const getPrismaModule: (Name: string, name: string) => string;

package/src/templates/prisma-module.template.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrismaModule = void 0;
+const getPrismaModule = (Name, name) => `import { Module } from '@nestjs/common';
+import { ${Name}Controller } from './${name}.controller';
+import { ${Name}Service } from './${name}.service';
+
+@Module({
+  controllers: [${Name}Controller],
+  providers: [
+    ${Name}Service,
+  ],
+  exports: [${Name}Service],
+})
+export class ${Name}Module {}
+`;
+exports.getPrismaModule = getPrismaModule;
+//# sourceMappingURL=prisma-module.template.js.map

package/src/templates/prisma-module.template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma-module.template.js","sourceRoot":"","sources":["../../../../../packages/cli/src/templates/prisma-module.template.ts"],"names":[],"mappings":";;;AACO,MAAM,eAAe,GAAG,CAAC,IAAY,EAAE,IAAY,EAAU,EAAE,CAAC;WAC5D,IAAI,wBAAwB,IAAI;WAChC,IAAI,qBAAqB,IAAI;;;kBAGtB,IAAI;;MAEhB,IAAI;;cAEI,IAAI;;eAEH,IAAI;CAClB,CAAC;AAZW,QAAA,eAAe,mBAY1B"}

package/src/templates/prisma-service.template.d.ts

@@ -0,0 +1 @@
+export declare const getPrismaService: (Name: string, name: string) => string;

package/src/templates/prisma-service.template.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrismaService = void 0;
+const getPrismaService = (Name, name) => `import { Injectable } from '@nestjs/common';
+import { PrismaService } from 'src/prisma/prisma.service';
+import { NestService } from '@nest-extended/prisma';
+
+@Injectable()
+export class ${Name}Service extends NestService<any> {
+  constructor(private readonly prisma: PrismaService) {
+    super(prisma.${name});
+  }
+}`;
+exports.getPrismaService = getPrismaService;
+//# sourceMappingURL=prisma-service.template.js.map

package/src/templates/prisma-service.template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma-service.template.js","sourceRoot":"","sources":["../../../../../packages/cli/src/templates/prisma-service.template.ts"],"names":[],"mappings":";;;AACO,MAAM,gBAAgB,GAAG,CAAC,IAAY,EAAE,IAAY,EAAU,EAAE,CAAC;;;;;eAKzD,IAAI;;mBAEA,IAAI;;EAErB,CAAC;AATU,QAAA,gBAAgB,oBAS1B"}

package/src/templates/prisma-setup.template.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates PrismaService (extends PrismaClient) and PrismaModule.
+ * Created once per project — shared across all Prisma-based services.
+ */
+export declare const getPrismaServiceFile: () => string;
+export declare const getPrismaModuleFile: () => string;

package/src/templates/prisma-setup.template.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Generates PrismaService (extends PrismaClient) and PrismaModule.
+ * Created once per project — shared across all Prisma-based services.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrismaModuleFile = exports.getPrismaServiceFile = void 0;
+const getPrismaServiceFile = () => `import { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+
+@Injectable()
+export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
+  async onModuleInit() {
+    await this.$connect();
+  }
+
+  async onModuleDestroy() {
+    await this.$disconnect();
+  }
+}
+`;
+exports.getPrismaServiceFile = getPrismaServiceFile;
+const getPrismaModuleFile = () => `import { Global, Module } from '@nestjs/common';
+import { PrismaService } from './prisma.service';
+
+@Global()
+@Module({
+  providers: [PrismaService],
+  exports: [PrismaService],
+})
+export class PrismaModule {}
+`;
+exports.getPrismaModuleFile = getPrismaModuleFile;
+//# sourceMappingURL=prisma-setup.template.js.map

package/src/templates/prisma-setup.template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma-setup.template.js","sourceRoot":"","sources":["../../../../../packages/cli/src/templates/prisma-setup.template.ts"],"names":[],"mappings":";AACA;;;GAGG;;;AAEI,MAAM,oBAAoB,GAAG,GAAW,EAAE,CAAC;;;;;;;;;;;;;CAajD,CAAC;AAbW,QAAA,oBAAoB,wBAa/B;AAEK,MAAM,mBAAmB,GAAG,GAAW,EAAE,CAAC;;;;;;;;;CAShD,CAAC;AATW,QAAA,mBAAmB,uBAS9B"}

package/src/templates/prisma-users.template.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Prisma-compatible Users templates.
+ * Same functionality as the Mongoose users templates but using Prisma.
+ */
+export declare const getPrismaUsersModel: () => string;
+export declare const getPrismaUsersService: () => string;
+export declare const getPrismaUsersController: () => string;
+export declare const getPrismaUsersModule: () => string;