adorn-api 1.1.4 → 1.1.6

package/tests/unit/crud-controller-factory.test.ts

@@ -0,0 +1,222 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildOpenApi,
+  createCrudController,
+  createMetalCrudDtoClasses,
+  t,
+  type RequestContext
+} from "../../src/index";
+import { getControllerMeta } from "../../src/core/metadata";
+import { Column, Entity, PrimaryKey, col } from "metal-orm";
+
+@Entity({ tableName: "crud_factory_entities" })
+class CrudFactoryEntity {
+  @PrimaryKey(col.autoIncrement(col.int()))
+  id!: number;
+
+  @Column(col.notNull(col.text()))
+  nome!: string;
+
+  @Column(col.notNull(col.boolean()))
+  ativo!: boolean;
+}
+
+const crudDtos = createMetalCrudDtoClasses(CrudFactoryEntity, {
+  mutationExclude: ["id"],
+  query: {
+    filters: {
+      nomeContains: {
+        schema: t.string({ minLength: 1 }),
+        field: "nome",
+        operator: "contains"
+      },
+      ativo: {
+        schema: t.boolean(),
+        field: "ativo",
+        operator: "equals"
+      }
+    },
+    sortableColumns: {
+      id: "id",
+      nome: "nome"
+    },
+    options: {
+      labelField: "nome"
+    }
+  },
+  errors: true
+});
+
+class CrudFactoryService {
+  async list(_ctx: RequestContext<unknown, InstanceType<typeof crudDtos.queryDto>>) {
+    return { items: [], total: 0, page: 1, pageSize: 25 } as InstanceType<typeof crudDtos.pagedResponseDto>;
+  }
+
+  async options(_ctx: RequestContext<unknown, InstanceType<typeof crudDtos.optionsQueryDto>>) {
+    return { items: [], total: 0, page: 1, pageSize: 25 } as InstanceType<typeof crudDtos.optionsDto>;
+  }
+
+  async getById(
+    id: number,
+    _ctx: RequestContext<unknown, undefined, InstanceType<typeof crudDtos.params>>
+  ) {
+    return { id, nome: "Teste", ativo: true } as InstanceType<typeof crudDtos.response>;
+  }
+
+  async create(
+    body: InstanceType<typeof crudDtos.create>,
+    _ctx: RequestContext<InstanceType<typeof crudDtos.create>>
+  ) {
+    return { id: 1, ...body } as InstanceType<typeof crudDtos.response>;
+  }
+
+  async replace(
+    id: number,
+    body: InstanceType<typeof crudDtos.replace>,
+    _ctx: RequestContext<InstanceType<typeof crudDtos.replace>, undefined, InstanceType<typeof crudDtos.params>>
+  ) {
+    return { id, ...body } as InstanceType<typeof crudDtos.response>;
+  }
+
+  async update(
+    id: number,
+    body: InstanceType<typeof crudDtos.update>,
+    _ctx: RequestContext<InstanceType<typeof crudDtos.update>, undefined, InstanceType<typeof crudDtos.params>>
+  ) {
+    return { id, ...body } as InstanceType<typeof crudDtos.response>;
+  }
+
+  async delete(
+    _id: number,
+    _ctx: RequestContext<unknown, undefined, InstanceType<typeof crudDtos.params>>
+  ) {}
+}
+
+const CrudFactoryController = createCrudController({
+  path: "/crud-factory",
+  service: CrudFactoryService,
+  dtos: crudDtos,
+  entityName: "CrudFactoryEntity"
+});
+
+describe("createCrudController", () => {
+  it("registers CRUD routes with expected schemas and statuses", () => {
+    const meta = getControllerMeta(CrudFactoryController);
+    expect(meta).toBeDefined();
+    expect(meta?.basePath).toBe("/crud-factory");
+
+    const routeKeys = (meta?.routes ?? [])
+      .map((route) => `${route.httpMethod} ${route.path}`)
+      .sort();
+
+    expect(routeKeys).toEqual([
+      "delete /:id",
+      "get /",
+      "get /:id",
+      "get /options",
+      "patch /:id",
+      "post /",
+      "put /:id"
+    ]);
+
+    const byKey = new Map(
+      (meta?.routes ?? []).map((route) => [`${route.httpMethod} ${route.path}`, route] as const)
+    );
+
+    const listRoute = byKey.get("get /");
+    expect(listRoute?.query?.schema).toBe(crudDtos.queryDto);
+    expect(listRoute?.responses).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ status: 200, schema: crudDtos.pagedResponseDto })
+      ])
+    );
+
+    const optionsRoute = byKey.get("get /options");
+    expect(optionsRoute?.query?.schema).toBe(crudDtos.optionsQueryDto);
+    expect(optionsRoute?.responses).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ status: 200, schema: crudDtos.optionsDto })
+      ])
+    );
+
+    const createRoute = byKey.get("post /");
+    expect(createRoute?.body?.schema).toBe(crudDtos.create);
+    expect(createRoute?.responses).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ status: 201, schema: crudDtos.response })
+      ])
+    );
+
+    for (const key of ["get /:id", "put /:id", "patch /:id", "delete /:id"]) {
+      const route = byKey.get(key);
+      expect(route?.params?.schema).toBe(crudDtos.params);
+      expect(route?.responses).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ status: 400, error: true }),
+          expect.objectContaining({ status: 404, error: true })
+        ])
+      );
+    }
+
+    expect(byKey.get("put /:id")?.body?.schema).toBe(crudDtos.replace);
+    expect(byKey.get("patch /:id")?.body?.schema).toBe(crudDtos.update);
+    expect(byKey.get("delete /:id")?.responses).toEqual(
+      expect.arrayContaining([expect.objectContaining({ status: 204 })])
+    );
+  });
+
+  it("exposes matching schemas/status in OpenAPI", () => {
+    const doc = buildOpenApi({
+      info: { title: "Test API", version: "1.0.0" },
+      controllers: [CrudFactoryController]
+    });
+
+    const listResponses = (doc.paths["/crud-factory"]?.get as Record<string, any>)?.responses;
+    const createResponses = (doc.paths["/crud-factory"]?.post as Record<string, any>)?.responses;
+    const getByIdResponses = (doc.paths["/crud-factory/{id}"]?.get as Record<string, any>)?.responses;
+    const deleteResponses = (doc.paths["/crud-factory/{id}"]?.delete as Record<string, any>)?.responses;
+
+    expect(listResponses?.["200"]).toBeDefined();
+    expect(createResponses?.["201"]).toBeDefined();
+    expect(getByIdResponses?.["200"]).toBeDefined();
+    expect(getByIdResponses?.["400"]).toBeDefined();
+    expect(getByIdResponses?.["404"]).toBeDefined();
+    expect(deleteResponses?.["204"]).toBeDefined();
+  });
+
+  it("supports disabling optional routes with flags", () => {
+    const MinimalController = createCrudController({
+      path: "/crud-factory-minimal",
+      service: new CrudFactoryService(),
+      dtos: crudDtos,
+      entityName: "CrudFactoryEntity",
+      withOptionsRoute: false,
+      withReplace: false,
+      withPatch: false,
+      withDelete: false
+    });
+
+    const meta = getControllerMeta(MinimalController);
+    const routeKeys = (meta?.routes ?? [])
+      .map((route) => `${route.httpMethod} ${route.path}`)
+      .sort();
+
+    expect(routeKeys).toEqual([
+      "get /",
+      "get /:id",
+      "post /"
+    ]);
+  });
+
+  it("uses entityName in parseIdOrThrow messages", async () => {
+    const controller = new CrudFactoryController();
+    await expect(
+      controller.getById({
+        params: { id: "invalid" }
+      } as any)
+    ).rejects.toMatchObject({
+      status: 400,
+      message: "Invalid CrudFactoryEntity id."
+    });
+  });
+});

package/tests/unit/crud-dtos.test.ts

@@ -7,98 +7,98 @@ import type { FilterMapping } from "../../src/adapter/metal-orm/index";
 import { getDtoMeta } from "../../src/core/metadata";
 import { t } from "../../src/core/schema";
 import { Alphanumeric, Column, Email, Entity, Length, Pattern, PrimaryKey, col } from "metal-orm";
-
-describe("createMetalCrudDtos", () => {
-  @Entity({ tableName: "crud_dto_entities" })
-  class CrudDtoEntity {
-    @PrimaryKey(col.autoIncrement(col.int()))
-    id!: number;
-
-    @Column(col.notNull(col.text()))
-    name!: string;
-
-    @Column(col.text())
-    nickname?: string | null;
-  }
-
-  it("creates CRUD DTO decorators with defaults", () => {
-    const crud = createMetalCrudDtos(CrudDtoEntity, {
-      mutationExclude: ["id"]
-    });
-
-    @crud.response
-    class CrudDto {}
-
-    @crud.create
-    class CreateCrudDto {}
-
-    @crud.update
-    class UpdateCrudDto {}
-
-    @crud.params
-    class CrudParamsDto {}
-
-    const responseMeta = getDtoMeta(CrudDto);
-    const createMeta = getDtoMeta(CreateCrudDto);
-    const updateMeta = getDtoMeta(UpdateCrudDto);
-    const paramsMeta = getDtoMeta(CrudParamsDto);
-
-    expect(responseMeta?.fields.id).toBeDefined();
-    expect(createMeta?.fields.id).toBeUndefined();
-    expect(updateMeta?.fields.name?.optional).toBe(true);
-    expect(Object.keys(paramsMeta?.fields ?? {})).toEqual(["id"]);
-  });
-
-  @Entity({ tableName: "transformer_entities" })
-  class TransformerEntity {
-    @PrimaryKey(col.autoIncrement(col.int()))
-    id!: number;
-
-    @Column(col.varchar(50))
-    @Length({ min: 2, max: 10 })
-    name!: string;
-
-    @Column(col.text())
-    @Pattern({ pattern: /^[A-Z]+$/ })
-    code!: string;
-
-    @Column(col.text())
-    @Email()
-    email!: string;
-
-    @Column(col.text())
-    @Alphanumeric({ allowHyphens: true })
-    slug!: string;
-  }
-
-  it("maps transformer validators into string schemas", () => {
-    const crud = createMetalCrudDtos(TransformerEntity);
-
-    @crud.create
-    class CreateTransformerDto {}
-
-    const meta = getDtoMeta(CreateTransformerDto);
-    expect((meta?.fields.email?.schema as any).format).toBe("email");
-    expect((meta?.fields.name?.schema as any).minLength).toBe(2);
-    expect((meta?.fields.name?.schema as any).maxLength).toBe(10);
-    expect((meta?.fields.code?.schema as any).pattern).toBe("^[A-Z]+$");
-    expect((meta?.fields.slug?.schema as any).pattern).toBe("^[a-zA-Z0-9-]*$");
-  });
-});
-
-describe("createMetalCrudDtoClasses", () => {
-  @Entity({ tableName: "crud_dto_class_entities" })
-  class CrudDtoClassEntity {
-    @PrimaryKey(col.autoIncrement(col.int()))
-    id!: number;
-
-    @Column(col.notNull(col.text()))
-    name!: string;
-
-    @Column(col.text())
-    nickname?: string | null;
-  }
-
+
+describe("createMetalCrudDtos", () => {
+  @Entity({ tableName: "crud_dto_entities" })
+  class CrudDtoEntity {
+    @PrimaryKey(col.autoIncrement(col.int()))
+    id!: number;
+
+    @Column(col.notNull(col.text()))
+    name!: string;
+
+    @Column(col.text())
+    nickname?: string | null;
+  }
+
+  it("creates CRUD DTO decorators with defaults", () => {
+    const crud = createMetalCrudDtos(CrudDtoEntity, {
+      mutationExclude: ["id"]
+    });
+
+    @crud.response
+    class CrudDto {}
+
+    @crud.create
+    class CreateCrudDto {}
+
+    @crud.update
+    class UpdateCrudDto {}
+
+    @crud.params
+    class CrudParamsDto {}
+
+    const responseMeta = getDtoMeta(CrudDto);
+    const createMeta = getDtoMeta(CreateCrudDto);
+    const updateMeta = getDtoMeta(UpdateCrudDto);
+    const paramsMeta = getDtoMeta(CrudParamsDto);
+
+    expect(responseMeta?.fields.id).toBeDefined();
+    expect(createMeta?.fields.id).toBeUndefined();
+    expect(updateMeta?.fields.name?.optional).toBe(true);
+    expect(Object.keys(paramsMeta?.fields ?? {})).toEqual(["id"]);
+  });
+
+  @Entity({ tableName: "transformer_entities" })
+  class TransformerEntity {
+    @PrimaryKey(col.autoIncrement(col.int()))
+    id!: number;
+
+    @Column(col.varchar(50))
+    @Length({ min: 2, max: 10 })
+    name!: string;
+
+    @Column(col.text())
+    @Pattern({ pattern: /^[A-Z]+$/ })
+    code!: string;
+
+    @Column(col.text())
+    @Email()
+    email!: string;
+
+    @Column(col.text())
+    @Alphanumeric({ allowHyphens: true })
+    slug!: string;
+  }
+
+  it("maps transformer validators into string schemas", () => {
+    const crud = createMetalCrudDtos(TransformerEntity);
+
+    @crud.create
+    class CreateTransformerDto {}
+
+    const meta = getDtoMeta(CreateTransformerDto);
+    expect((meta?.fields.email?.schema as any).format).toBe("email");
+    expect((meta?.fields.name?.schema as any).minLength).toBe(2);
+    expect((meta?.fields.name?.schema as any).maxLength).toBe(10);
+    expect((meta?.fields.code?.schema as any).pattern).toBe("^[A-Z]+$");
+    expect((meta?.fields.slug?.schema as any).pattern).toBe("^[a-zA-Z0-9-]*$");
+  });
+});
+
+describe("createMetalCrudDtoClasses", () => {
+  @Entity({ tableName: "crud_dto_class_entities" })
+  class CrudDtoClassEntity {
+    @PrimaryKey(col.autoIncrement(col.int()))
+    id!: number;
+
+    @Column(col.notNull(col.text()))
+    name!: string;
+
+    @Column(col.text())
+    nickname?: string | null;
+  }
+
   it("builds ready-to-export DTO classes", () => {
     const classes = createMetalCrudDtoClasses(CrudDtoClassEntity, {
       mutationExclude: ["id"]
@@ -127,16 +127,16 @@ describe("createMetalCrudDtoClasses", () => {
     });
     expect(classes.sortableColumns).toEqual({});
   });
-
-  it("applies custom name overrides", () => {
-    const classes = createMetalCrudDtoClasses(CrudDtoClassEntity, {
-      baseName: "Person",
-      names: {
-        response: "PersonDto",
-        params: "PersonIdDto"
-      }
-    });
-
+
+  it("applies custom name overrides", () => {
+    const classes = createMetalCrudDtoClasses(CrudDtoClassEntity, {
+      baseName: "Person",
+      names: {
+        response: "PersonDto",
+        params: "PersonIdDto"
+      }
+    });
+
     expect(classes.response.name).toBe("PersonDto");
     expect(classes.params.name).toBe("PersonIdDto");
     expect(classes.create.name).toBe("CreatePersonDto");
@@ -197,4 +197,52 @@ describe("createMetalCrudDtoClasses", () => {
     });
     expect(typeof classes.errors).toBe("function");
   });
+
+  it("exposes listConfig with all query defaults ready for service layer", () => {
+    const classes = createMetalCrudDtoClasses(CrudDtoClassEntity, {
+      query: {
+        filters: {
+          nameContains: {
+            schema: t.string({ minLength: 1 }),
+            field: "name",
+            operator: "contains"
+          }
+        },
+        sortableColumns: {
+          name: "name",
+          nickname: "nickname"
+        },
+        defaultSortBy: "name",
+        defaultSortDirection: "desc",
+        defaultPageSize: 10,
+        maxPageSize: 50
+      }
+    });
+
+    expect(classes.listConfig).toEqual({
+      filterMappings: classes.filterMappings,
+      sortableColumns: { name: "name", nickname: "nickname" },
+      defaultSortBy: "name",
+      defaultSortDirection: "desc",
+      defaultPageSize: 10,
+      maxPageSize: 50,
+      sortByKey: "sortBy",
+      sortDirectionKey: "sortDirection"
+    });
+  });
+
+  it("listConfig uses sensible defaults when query options are minimal", () => {
+    const classes = createMetalCrudDtoClasses(CrudDtoClassEntity);
+
+    expect(classes.listConfig).toEqual({
+      filterMappings: classes.filterMappings,
+      sortableColumns: {},
+      defaultSortBy: undefined,
+      defaultSortDirection: "asc",
+      defaultPageSize: 25,
+      maxPageSize: 100,
+      sortByKey: "sortBy",
+      sortDirectionKey: "sortDirection"
+    });
+  });
 });

package/tests/unit/parse-sort.test.ts

@@ -45,4 +45,115 @@ describe("parseSort", () => {
       field: "createdAt"
     });
   });
+
+  it("parses sortOrder with uppercase DESC", () => {
+    const result = parseSort({
+      query: { sortBy: "name", sortOrder: "DESC" },
+      sortableColumns: { name: "name" }
+    });
+    expect(result).toEqual({
+      sortBy: "name",
+      sortDirection: "desc",
+      field: "name"
+    });
+  });
+
+  it("parses sortOrder with uppercase ASC", () => {
+    const result = parseSort({
+      query: { sortBy: "name", sortOrder: "ASC" },
+      sortableColumns: { name: "name" }
+    });
+    expect(result).toEqual({
+      sortBy: "name",
+      sortDirection: "asc",
+      field: "name"
+    });
+  });
+
+  it("gives sortDirection precedence over sortOrder when both present", () => {
+    const result = parseSort({
+      query: { sortBy: "name", sortDirection: "asc", sortOrder: "DESC" },
+      sortableColumns: { name: "name" }
+    });
+    expect(result).toEqual({
+      sortBy: "name",
+      sortDirection: "asc",
+      field: "name"
+    });
+  });
+
+  it("falls back to sortOrder when sortDirection is absent", () => {
+    const result = parseSort({
+      query: { sortBy: "name", sortOrder: "desc" },
+      sortableColumns: { name: "name" }
+    });
+    expect(result).toEqual({
+      sortBy: "name",
+      sortDirection: "desc",
+      field: "name"
+    });
+  });
+
+  it("falls back to default when neither sortDirection nor sortOrder present", () => {
+    const result = parseSort({
+      query: { sortBy: "name" },
+      sortableColumns: { name: "name" },
+      defaultSortDirection: "desc"
+    });
+    expect(result).toEqual({
+      sortBy: "name",
+      sortDirection: "desc",
+      field: "name"
+    });
+  });
+
+  it("supports custom sortOrderKey", () => {
+    const result = parseSort({
+      query: { sortBy: "name", order: "DESC" },
+      sortableColumns: { name: "name" },
+      sortOrderKey: "order"
+    });
+    expect(result).toEqual({
+      sortBy: "name",
+      sortDirection: "desc",
+      field: "name"
+    });
+  });
+
+  it("ignores invalid sortOrder values and uses default", () => {
+    const result = parseSort({
+      query: { sortBy: "name", sortOrder: "INVALID" },
+      sortableColumns: { name: "name" },
+      defaultSortDirection: "asc"
+    });
+    expect(result).toEqual({
+      sortBy: "name",
+      sortDirection: "asc",
+      field: "name"
+    });
+  });
+
+  it("normalizes mixed-case sortDirection (e.g. Desc)", () => {
+    const result = parseSort({
+      query: { sortBy: "name", sortDirection: "Desc" },
+      sortableColumns: { name: "name" }
+    });
+    expect(result).toEqual({
+      sortBy: "name",
+      sortDirection: "desc",
+      field: "name"
+    });
+  });
+
+  it("works with positional args and sortOrder fallback", () => {
+    const result = parseSort(
+      { sortBy: "name", sortOrder: "DESC" },
+      { name: "name" }
+    );
+    expect(result).toEqual({
+      sortBy: "name",
+      sortDirection: "desc",
+      field: "name"
+    });
+  });
 });