Crudify

// app.module.ts
import { Module } from "@nestjs/common";
import { MongooseModule } from "@nestjs/mongoose";
import { CrudifyModule } from "ncrudify";
import { UserModule } from "./user/user.module";

@Module({
  imports: [
    MongooseModule.forRoot(process.env.MONGODB_URI!),
    CrudifyModule.forRoot(),
    UserModule,
  ],
})
export class AppModule {}

import { NestFactory } from "@nestjs/core";
import { AppModule } from "./app.module";

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.set("query parser", "extended");
  await app.listen(3000);
}

bootstrap();

// user/entities/user.entity.ts
import { Prop, Schema, SchemaFactory } from "@nestjs/mongoose";
import { ApiProperty } from "@nestjs/swagger";
import { HydratedDocument } from "mongoose";

export type UserDocument = HydratedDocument<User>;

@Schema({ timestamps: true })
export class User {
  @ApiProperty({ example: "John Doe" })
  @Prop({ required: true })
  name!: string;

  @ApiProperty({ example: "john@example.com" })
  @Prop({ required: true, unique: true })
  email!: string;

  @ApiProperty({ example: 30, required: false })
  @Prop()
  age?: number;
}

export const UserSchema = SchemaFactory.createForClass(User);

// user/user.service.ts
import { Injectable } from "@nestjs/common";
import { InjectModel } from "@nestjs/mongoose";
import { Model } from "mongoose";
import { CrudifyService } from "ncrudify";
import { User } from "./entities/user.entity";

@Injectable()
export class UserService extends CrudifyService<User> {
  constructor(@InjectModel(User.name) protected readonly userModel: Model<User>) {
    super(userModel);
  }
}

// user/user.controller.ts
import { Controller } from "@nestjs/common";
import { ApiTags } from "@nestjs/swagger";
import { Crudify, CrudifyController } from "ncrudify";
import { User, UserSchema } from "./entities/user.entity";
import { UserService } from "./user.service";

@ApiTags("users")
@Crudify({
  model: {
    type: User,
    schema: UserSchema,
  },
})
@Controller("users")
export class UserController extends CrudifyController<User> {
  constructor(public readonly service: UserService) {
    super(service);
  }
}

// user/user.module.ts
import { Module } from "@nestjs/common";
import { MongooseModule } from "@nestjs/mongoose";
import { User, UserSchema } from "./entities/user.entity";
import { UserController } from "./user.controller";
import { UserService } from "./user.service";

@Module({
  imports: [
    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
  ],
  controllers: [UserController],
  providers: [UserService],
})
export class UserModule {}

@Crudify({
  model: {
    type: User,
    cdto: CreateUserDto,
    udto: UpdateUserDto,
    schema: UserSchema,
  },
  softDelete: true,
  routes: {
    exclude: ["deleteBulk"],
    disableBulk: false,
    decorators: [UseGuards(AuthGuard)],
    config: {
      findAll: {
        decorators: [ApiBearerAuth()],
      },
      delete: {
        disabled: true,
      },
    },
  },
})
@Controller("users")
export class UserController extends CrudifyController<User> {}

async findAll(query: any) {
  const result = await super.findAll(query);
  return {
    ...result,
    results: result.results.filter((user) => user.active),
  };
}

@Get(":id")
findOne(@Param("id") id: string) {
  return this.service.findOne({ _id: id });
}

CrudifyModule.forRoot();

CrudifyModule.forRoot({
  audit: {
    enabled: true,
    collectionName: "audit_logs",
    userExtractor: (request) =>
      request.user?._id ?? request.user?.email ?? "anonymous",
  },
});

interface AuditLogRecord {
  user: string;
  action: string;
  entityId: string | null;
  details: Record<string, any>;
  createdAt?: Date | string;
}

import { NoAudit } from "ncrudify";

@NoAudit("GET/:id")
@Get(":id")
findOne() {
  // ...
}

@Crudify({
  model: {
    type: User,
  },
  softDelete: true,
})
@Controller("users")
export class UserController extends CrudifyController<User> {}

@Injectable()
export class UserService extends CrudifyService<User> {
  constructor(@InjectModel(User.name) model: Model<User>) {
    super(model);
  }

  async findAll(query: any) {
    const result = await super.findAll(query);
    return {
      ...result,
      results: result.results.sort((a, b) => a.name.localeCompare(b.name)),
    };
  }
}

@Crudify({ model: { type: User } })
@Controller("users")
export class UserController extends CrudifyController<User> {
  constructor(public service: UserService) {
    super(service);
  }

  @Get(":id")
  findOne(@Param("id") id: string) {
    return this.service.findOne({ _id: id });
  }
}

import { DocumentBuilder, SwaggerModule } from "@nestjs/swagger";

const config = new DocumentBuilder()
  .setTitle("Crudify API")
  .setDescription("API generated with Crudify")
  .setVersion("1.0")
  .addBearerAuth()
  .build();

const document = SwaggerModule.createDocument(app, config);
SwaggerModule.setup("docs", app, document, {
  swaggerOptions: { filter: true },
});