adorn-api 1.1.4 → 1.1.6

package/src/adapter/metal-orm/crud-controller.ts

@@ -0,0 +1,188 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Params,
+  Patch,
+  Post,
+  Put,
+  Query,
+  Returns
+} from "../../core/decorators";
+import type { DtoConstructor } from "../../core/types";
+import type { RequestContext } from "../express/types";
+import type {
+  CreateCrudControllerOptions,
+  CrudControllerService,
+  CrudControllerServiceInput,
+  MetalCrudDtoClasses,
+  RouteErrorsDecorator
+} from "./types";
+import { parseIdOrThrow } from "./utils";
+
+type DtoInstance<TDto extends DtoConstructor> = InstanceType<TDto>;
+type MethodDecorator = (
+  value: unknown,
+  context: ClassMethodDecoratorContext
+) => void;
+
+export function createCrudController<TDtos extends MetalCrudDtoClasses<any>>(
+  options: CreateCrudControllerOptions<TDtos>
+) {
+  const withOptionsRoute = options.withOptionsRoute ?? true;
+  const withReplace = options.withReplace ?? true;
+  const withPatch = options.withPatch ?? true;
+  const withDelete = options.withDelete ?? true;
+  const service = resolveService(options.service);
+  const routeErrorsDecorator = options.dtos.errors;
+
+  @Controller({ path: options.path, tags: options.tags })
+  class GeneratedCrudController {
+    @Get("/")
+    @Query(options.dtos.queryDto)
+    @Returns(options.dtos.pagedResponseDto)
+    async list(
+      ctx: RequestContext<unknown, DtoInstance<TDtos["queryDto"]>>
+    ): Promise<DtoInstance<TDtos["pagedResponseDto"]>> {
+      return await service.list(ctx);
+    }
+
+    @when(withOptionsRoute, Get("/options"))
+    @when(withOptionsRoute, Query(options.dtos.optionsQueryDto))
+    @when(withOptionsRoute, Returns(options.dtos.optionsDto))
+    async options(
+      ctx: RequestContext<unknown, DtoInstance<TDtos["optionsQueryDto"]>>
+    ): Promise<DtoInstance<TDtos["optionsDto"]>> {
+      assertServiceMethod(service, "options");
+      return await service.options(ctx);
+    }
+
+    @Get("/:id")
+    @Params(options.dtos.params)
+    @Returns(options.dtos.response)
+    @applyRouteErrors(routeErrorsDecorator)
+    async getById(
+      ctx: RequestContext<unknown, undefined, DtoInstance<TDtos["params"]>>
+    ): Promise<DtoInstance<TDtos["response"]>> {
+      const id = parseContextId(ctx, options.entityName);
+      return await service.getById(id, ctx);
+    }
+
+    @Post("/")
+    @Body(options.dtos.create)
+    @Returns({ status: 201, schema: options.dtos.response })
+    async create(
+      ctx: RequestContext<DtoInstance<TDtos["create"]>>
+    ): Promise<DtoInstance<TDtos["response"]>> {
+      return await service.create(ctx.body, ctx);
+    }
+
+    @when(withReplace, Put("/:id"))
+    @when(withReplace, Params(options.dtos.params))
+    @when(withReplace, Body(options.dtos.replace))
+    @when(withReplace, Returns(options.dtos.response))
+    @when(withReplace, applyRouteErrors(routeErrorsDecorator))
+    async replace(
+      ctx: RequestContext<
+        DtoInstance<TDtos["replace"]>,
+        undefined,
+        DtoInstance<TDtos["params"]>
+      >
+    ): Promise<DtoInstance<TDtos["response"]>> {
+      assertServiceMethod(service, "replace");
+      const id = parseContextId(ctx, options.entityName);
+      return await service.replace(id, ctx.body, ctx);
+    }
+
+    @when(withPatch, Patch("/:id"))
+    @when(withPatch, Params(options.dtos.params))
+    @when(withPatch, Body(options.dtos.update))
+    @when(withPatch, Returns(options.dtos.response))
+    @when(withPatch, applyRouteErrors(routeErrorsDecorator))
+    async update(
+      ctx: RequestContext<
+        DtoInstance<TDtos["update"]>,
+        undefined,
+        DtoInstance<TDtos["params"]>
+      >
+    ): Promise<DtoInstance<TDtos["response"]>> {
+      assertServiceMethod(service, "update");
+      const id = parseContextId(ctx, options.entityName);
+      return await service.update(id, ctx.body, ctx);
+    }
+
+    @when(withDelete, Delete("/:id"))
+    @when(withDelete, Params(options.dtos.params))
+    @when(withDelete, Returns({ status: 204, description: "No Content" }))
+    @when(withDelete, applyRouteErrors(routeErrorsDecorator))
+    async delete(
+      ctx: RequestContext<unknown, undefined, DtoInstance<TDtos["params"]>>
+    ): Promise<void> {
+      assertServiceMethod(service, "delete");
+      const id = parseContextId(ctx, options.entityName);
+      await service.delete(id, ctx);
+    }
+  }
+
+  Object.defineProperty(GeneratedCrudController, "name", {
+    value: `${options.entityName}CrudController`,
+    configurable: true
+  });
+
+  return GeneratedCrudController;
+}
+
+function resolveService<TDtos extends MetalCrudDtoClasses<any>>(
+  input: CrudControllerServiceInput<TDtos>
+): CrudControllerService<TDtos> {
+  if (typeof input === "function") {
+    return new input();
+  }
+  return input;
+}
+
+function when(enabled: boolean, decorator: MethodDecorator): MethodDecorator {
+  return (value, context) => {
+    if (enabled) {
+      decorator(value, context);
+    }
+  };
+}
+
+function applyRouteErrors(
+  decorator: RouteErrorsDecorator | undefined
+): MethodDecorator {
+  return (value, context) => {
+    decorator?.(value, context);
+  };
+}
+
+function parseContextId(
+  ctx: RequestContext<unknown, undefined, object | undefined>,
+  entityName: string
+): number {
+  const params = (ctx.params ?? {}) as Record<string, unknown>;
+  return parseIdOrThrow(toIdValue(params.id), entityName);
+}
+
+function toIdValue(value: unknown): string | number {
+  if (typeof value === "string" || typeof value === "number") {
+    return value;
+  }
+  return "";
+}
+
+function assertServiceMethod<
+  TDtos extends MetalCrudDtoClasses<any>,
+  TMethod extends "options" | "replace" | "update" | "delete"
+>(
+  service: CrudControllerService<TDtos>,
+  method: TMethod
+): asserts service is CrudControllerService<TDtos> & Record<TMethod, NonNullable<CrudControllerService<TDtos>[TMethod]>> {
+  if (typeof service[method] !== "function") {
+    throw new Error(
+      `CRUD service is missing "${method}" method required by enabled route.`
+    );
+  }
+}

package/src/adapter/metal-orm/crud-dtos.ts

@@ -166,6 +166,17 @@ export function createMetalCrudDtoClasses<TEntity extends Record<string, unknown
 
   const errors = buildStandardCrudErrors(entityName, errorOptions);
 
+  const listConfig = {
+    filterMappings,
+    sortableColumns,
+    defaultSortBy: queryOptions.defaultSortBy,
+    defaultSortDirection: queryOptions.defaultSortDirection ?? "asc" as SortDirection,
+    defaultPageSize,
+    maxPageSize,
+    sortByKey,
+    sortDirectionKey
+  };
+
   return {
     response: crudClasses.response as DtoConstructor,
     create: crudClasses.create as DtoConstructor,
@@ -179,7 +190,8 @@ export function createMetalCrudDtoClasses<TEntity extends Record<string, unknown
     optionsDto,
     errors,
     filterMappings,
-    sortableColumns
+    sortableColumns,
+    listConfig
   };
 }
 

package/src/adapter/metal-orm/index.ts

@@ -1,17 +1,17 @@
-// Ensure standard decorator metadata is available for metal-orm transformers.
-const symbolMetadata = (Symbol as { metadata?: symbol }).metadata;
-if (!symbolMetadata) {
-  (Symbol as { metadata?: symbol }).metadata = Symbol("Symbol.metadata");
-}
-
-export {
-  MetalDto
-} from "./dto";
-
-export {
-  parsePagination
-} from "./pagination";
-
+// Ensure standard decorator metadata is available for metal-orm transformers.
+const symbolMetadata = (Symbol as { metadata?: symbol }).metadata;
+if (!symbolMetadata) {
+  (Symbol as { metadata?: symbol }).metadata = Symbol("Symbol.metadata");
+}
+
+export {
+  MetalDto
+} from "./dto";
+
+export {
+  parsePagination
+} from "./pagination";
+
 export {
   parseFilter,
   createFilterMappings
@@ -20,55 +20,59 @@ export {
 export {
   parseSort
 } from "./sort";
-
-export {
-  createPagedQueryDtoClass,
-  createPagedResponseDtoClass,
-  createPagedFilterQueryDtoClass
-} from "./paged-dtos";
-
+
+export {
+  createPagedQueryDtoClass,
+  createPagedResponseDtoClass,
+  createPagedFilterQueryDtoClass
+} from "./paged-dtos";
+
 export {
   createMetalCrudDtos,
   createMetalCrudDtoClasses,
   createNestedCreateDtoClass
 } from "./crud-dtos";
 
+export {
+  createCrudController
+} from "./crud-controller";
+
 export {
   createMetalTreeDtoClasses
 } from "./tree-dtos";
 
-export {
-  createMetalDtoOverrides,
-  type CreateMetalDtoOverridesOptions
-} from "./convention-overrides";
-
-export {
-  createErrorDtoClass,
-  StandardErrorDto,
-  SimpleErrorDto,
-  BasicErrorDto
-} from "./error-dtos";
-
-export {
-  withSession,
-  parseIdOrThrow,
-  compactUpdates,
-  applyInput,
-  getEntityOrThrow
-} from "./utils";
-
-export {
-  validateEntityMetadata,
-  hasValidEntityMetadata
-} from "./field-builder";
-
-export type {
-  MetalDtoMode,
-  MetalDtoOptions,
-  MetalDtoTarget,
-  PaginationConfig,
-  PaginationOptions,
-  ParsedPagination,
+export {
+  createMetalDtoOverrides,
+  type CreateMetalDtoOverridesOptions
+} from "./convention-overrides";
+
+export {
+  createErrorDtoClass,
+  StandardErrorDto,
+  SimpleErrorDto,
+  BasicErrorDto
+} from "./error-dtos";
+
+export {
+  withSession,
+  parseIdOrThrow,
+  compactUpdates,
+  applyInput,
+  getEntityOrThrow
+} from "./utils";
+
+export {
+  validateEntityMetadata,
+  hasValidEntityMetadata
+} from "./field-builder";
+
+export type {
+  MetalDtoMode,
+  MetalDtoOptions,
+  MetalDtoTarget,
+  PaginationConfig,
+  PaginationOptions,
+  ParsedPagination,
   Filter,
   FilterMapping,
   FilterFieldMapping,
@@ -80,6 +84,7 @@ export type {
   ParseSortOptions,
   ParsedSort,
   SortDirection,
+  ListConfig,
   PagedQueryDtoOptions,
   PagedResponseDtoOptions,
   PagedFilterQueryDtoOptions,
@@ -95,6 +100,9 @@ export type {
   MetalCrudDtoClasses,
   MetalCrudDtoClassNameKey,
   MetalCrudDtoClassNames,
+  CrudControllerService,
+  CrudControllerServiceInput,
+  CreateCrudControllerOptions,
   RouteErrorsDecorator,
   NestedCreateDtoOptions,
   MetalTreeDtoClassOptions,

package/src/adapter/metal-orm/sort.ts

@@ -31,6 +31,7 @@ export function parseSort<T>(
 
   const sortByKey = resolved.sortByKey ?? "sortBy";
   const sortDirectionKey = resolved.sortDirectionKey ?? "sortDirection";
+  const sortOrderKey = resolved.sortOrderKey ?? "sortOrder";
   const defaultSortBy = resolved.defaultSortBy;
   const defaultDirection = resolved.defaultSortDirection ?? "asc";
 
@@ -40,7 +41,8 @@ export function parseSort<T>(
     return undefined;
   }
 
-  const requestedDirection = toTrimmedString(query[sortDirectionKey]);
+  const requestedDirection = toTrimmedString(query[sortDirectionKey])
+    ?? toTrimmedString(query[sortOrderKey]);
   const sortDirection = normalizeDirection(requestedDirection, defaultDirection);
 
   return {
@@ -72,10 +74,11 @@ function normalizeDirection(
   raw: string | undefined,
   fallback: SortDirection
 ): SortDirection {
-  if (raw === "desc") {
+  const lower = raw?.toLowerCase();
+  if (lower === "desc") {
     return "desc";
   }
-  if (raw === "asc") {
+  if (lower === "asc") {
     return "asc";
   }
   return fallback;