metal-orm 1.0.90 → 1.0.92

package/src/dto/openapi/generators/pagination.ts

@@ -1,111 +1,111 @@
-import type { OpenApiSchema, OpenApiParameter } from '../types.js';
-
-export interface PaginationParams {
-  page?: number;
-  pageSize?: number;
-  sortBy?: string;
-  sortOrder?: 'asc' | 'desc';
-}
-
-export const paginationParamsSchema: OpenApiSchema = {
-  type: 'object',
-  properties: {
-    page: {
-      type: 'integer',
-      format: 'int32',
-      minimum: 1,
-      default: 1,
-      description: 'Page number (1-based)',
-    },
-    pageSize: {
-      type: 'integer',
-      format: 'int32',
-      minimum: 1,
-      maximum: 100,
-      default: 20,
-      description: 'Number of items per page',
-    },
-    sortBy: {
-      type: 'string',
-      description: 'Field name to sort by',
-    },
-    sortOrder: {
-      type: 'string',
-      enum: ['asc', 'desc'],
-      default: 'asc',
-      description: 'Sort order',
-    },
-  },
-};
-
-export function toPaginationParams(): OpenApiParameter[] {
-  return [
-    {
-      name: 'page',
-      in: 'query',
-      schema: paginationParamsSchema.properties?.page as OpenApiSchema,
-      description: 'Page number (1-based)',
-    },
-    {
-      name: 'pageSize',
-      in: 'query',
-      schema: paginationParamsSchema.properties?.pageSize as OpenApiSchema,
-      description: 'Number of items per page (max 100)',
-    },
-    {
-      name: 'sortBy',
-      in: 'query',
-      schema: paginationParamsSchema.properties?.sortBy as OpenApiSchema,
-      description: 'Field name to sort by',
-    },
-    {
-      name: 'sortOrder',
-      in: 'query',
-      schema: paginationParamsSchema.properties?.sortOrder as OpenApiSchema,
-      description: 'Sort order (asc or desc)',
-    },
-  ];
-}
-
-export function pagedResponseToOpenApiSchema<T extends OpenApiSchema>(
-  itemSchema: T
-): OpenApiSchema {
-  return {
-    type: 'object',
-    properties: {
-      items: {
-        type: 'array',
-        items: itemSchema,
-      },
-      totalItems: {
-        type: 'integer',
-        format: 'int64',
-        description: 'Total number of items matching the query',
-      },
-      page: {
-        type: 'integer',
-        format: 'int32',
-        description: 'Current page number (1-based)',
-      },
-      pageSize: {
-        type: 'integer',
-        format: 'int32',
-        description: 'Number of items per page',
-      },
-      totalPages: {
-        type: 'integer',
-        format: 'int32',
-        description: 'Total number of pages',
-      },
-      hasNextPage: {
-        type: 'boolean',
-        description: 'Whether there are more pages after the current one',
-      },
-      hasPrevPage: {
-        type: 'boolean',
-        description: 'Whether there are pages before the current one',
-      },
-    },
-    required: ['items', 'totalItems', 'page', 'pageSize', 'totalPages', 'hasNextPage', 'hasPrevPage'],
-  };
-}
+import type { OpenApiSchema, OpenApiParameter } from '../types.js';
+
+export interface PaginationParams {
+  page?: number;
+  pageSize?: number;
+  sortBy?: string;
+  sortOrder?: 'asc' | 'desc';
+}
+
+export const paginationParamsSchema: OpenApiSchema = {
+  type: 'object',
+  properties: {
+    page: {
+      type: 'integer',
+      format: 'int32',
+      minimum: 1,
+      default: 1,
+      description: 'Page number (1-based)',
+    },
+    pageSize: {
+      type: 'integer',
+      format: 'int32',
+      minimum: 1,
+      maximum: 100,
+      default: 20,
+      description: 'Number of items per page',
+    },
+    sortBy: {
+      type: 'string',
+      description: 'Field name to sort by',
+    },
+    sortOrder: {
+      type: 'string',
+      enum: ['asc', 'desc'],
+      default: 'asc',
+      description: 'Sort order',
+    },
+  },
+};
+
+export function toPaginationParams(): OpenApiParameter[] {
+  return [
+    {
+      name: 'page',
+      in: 'query',
+      schema: paginationParamsSchema.properties?.page as OpenApiSchema,
+      description: 'Page number (1-based)',
+    },
+    {
+      name: 'pageSize',
+      in: 'query',
+      schema: paginationParamsSchema.properties?.pageSize as OpenApiSchema,
+      description: 'Number of items per page (max 100)',
+    },
+    {
+      name: 'sortBy',
+      in: 'query',
+      schema: paginationParamsSchema.properties?.sortBy as OpenApiSchema,
+      description: 'Field name to sort by',
+    },
+    {
+      name: 'sortOrder',
+      in: 'query',
+      schema: paginationParamsSchema.properties?.sortOrder as OpenApiSchema,
+      description: 'Sort order (asc or desc)',
+    },
+  ];
+}
+
+export function pagedResponseToOpenApiSchema<T extends OpenApiSchema>(
+  itemSchema: T
+): OpenApiSchema {
+  return {
+    type: 'object',
+    properties: {
+      items: {
+        type: 'array',
+        items: itemSchema,
+      },
+      totalItems: {
+        type: 'integer',
+        format: 'int64',
+        description: 'Total number of items matching the query',
+      },
+      page: {
+        type: 'integer',
+        format: 'int32',
+        description: 'Current page number (1-based)',
+      },
+      pageSize: {
+        type: 'integer',
+        format: 'int32',
+        description: 'Number of items per page',
+      },
+      totalPages: {
+        type: 'integer',
+        format: 'int32',
+        description: 'Total number of pages',
+      },
+      hasNextPage: {
+        type: 'boolean',
+        description: 'Whether there are more pages after the current one',
+      },
+      hasPrevPage: {
+        type: 'boolean',
+        description: 'Whether there are pages before the current one',
+      },
+    },
+    required: ['items', 'totalItems', 'page', 'pageSize', 'totalPages', 'hasNextPage', 'hasPrevPage'],
+  };
+}

package/src/dto/openapi/generators/relation-filter.ts

@@ -1,210 +1,228 @@
-import type { TableDef } from '../../../schema/table.js';
-import type { EntityConstructor } from '../../../orm/entity-metadata.js';
-import {
-    RelationDef,
-    BelongsToRelation,
-    HasManyRelation,
-    HasOneRelation,
-    BelongsToManyRelation,
-    RelationKinds
-} from '../../../schema/relation.js';
-import type { OpenApiSchema } from '../types.js';
-import { columnToOpenApiSchema } from './column.js';
-import { getColumnMap } from './base.js';
-
-export function relationFilterToOpenApiSchema(
-    relation: RelationDef,
-    options?: {
-        exclude?: string[];
-        include?: string[];
-    }
-): OpenApiSchema {
-    if (relation.type === RelationKinds.BelongsTo || relation.type === RelationKinds.HasOne) {
-        return singleRelationFilterToOpenApiSchema((relation as BelongsToRelation | HasOneRelation).target, options);
-    }
-
-    if (relation.type === RelationKinds.HasMany || relation.type === RelationKinds.BelongsToMany) {
-        return manyRelationFilterToOpenApiSchema((relation as HasManyRelation | BelongsToManyRelation).target, options);
-    }
-
-    return { type: 'object', properties: {} };
-}
-
-function singleRelationFilterToOpenApiSchema(
-    target: TableDef | EntityConstructor,
-    options?: { exclude?: string[]; include?: string[] }
-): OpenApiSchema {
-    const columns = getColumnMap(target);
-    const properties: Record<string, OpenApiSchema> = {};
-    const required: string[] = [];
-
-    for (const [key, col] of Object.entries(columns)) {
-        if (options?.exclude?.includes(key)) {
-            continue;
-        }
-
-        if (options?.include && !options.include.includes(key)) {
-            continue;
-        }
-
-        properties[key] = columnToOpenApiSchema(col);
-
-        if (col.notNull || col.primary) {
-            required.push(key);
-        }
-    }
-
-    return {
-        type: 'object',
-        properties,
-        ...(required.length > 0 && { required }),
-    };
-}
-
-function manyRelationFilterToOpenApiSchema(
-    target: TableDef | EntityConstructor,
-    options?: { exclude?: string[]; include?: string[] }
-): OpenApiSchema {
-    return {
-        type: 'object',
-        properties: {
-            some: {
-                type: 'object',
-                description: 'Filter related records that match all conditions',
-                properties: generateNestedProperties(target, options),
-            },
-            every: {
-                type: 'object',
-                description: 'Filter related records where all match conditions',
-                properties: generateNestedProperties(target, options),
-            },
-            none: {
-                type: 'object',
-                description: 'Filter where no related records match',
-                properties: generateNestedProperties(target, options),
-            },
-            isEmpty: {
-                type: 'boolean',
-                description: 'Filter where relation has no related records',
-            },
-            isNotEmpty: {
-                type: 'boolean',
-                description: 'Filter where relation has related records',
-            },
-        },
-    };
-}
-
-function generateNestedProperties(
-    target: TableDef | EntityConstructor,
-    options?: { exclude?: string[]; include?: string[] }
-): Record<string, OpenApiSchema> {
-    const columns = getColumnMap(target);
-    const properties: Record<string, OpenApiSchema> = {};
-
-    for (const [key, col] of Object.entries(columns)) {
-        if (options?.exclude?.includes(key)) {
-            continue;
-        }
-
-        if (options?.include && !options.include.includes(key)) {
-            continue;
-        }
-
-        properties[key] = columnToOpenApiSchema(col);
-    }
-
-    return properties;
-}
-
-export function whereInputWithRelationsToOpenApiSchema<T extends TableDef | EntityConstructor>(
-    target: T,
-    options?: {
-        columnExclude?: string[];
-        columnInclude?: string[];
-        relationExclude?: string[];
-        relationInclude?: string[];
-        maxDepth?: number;
-    }
-): OpenApiSchema {
-    const columns = getColumnMap(target);
-    const properties: Record<string, OpenApiSchema> = {};
-    const depth = options?.maxDepth ?? 3;
-
-    for (const [key, col] of Object.entries(columns)) {
-        if (options?.columnExclude?.includes(key)) {
-            continue;
-        }
-
-        if (options?.columnInclude && !options.columnInclude.includes(key)) {
-            continue;
-        }
-
-        properties[key] = columnToOpenApiSchema(col);
-    }
-
-    const tableDef = target as TableDef;
-    if (tableDef.relations && depth > 0) {
-        for (const [relationName, relation] of Object.entries(tableDef.relations)) {
-            if (options?.relationExclude?.includes(relationName)) {
-                continue;
-            }
-
-            if (options?.relationInclude && !options.relationInclude.includes(relationName)) {
-                continue;
-            }
-
-            properties[relationName] = relationFilterToOpenApiSchema(relation, {
-                exclude: options?.columnExclude,
-                include: options?.columnInclude,
-            });
-        }
-    }
-
-    return {
-        type: 'object',
-        properties,
-    };
-}
-
-export function nestedWhereInputToOpenApiSchema<T extends TableDef | EntityConstructor>(
-    target: T,
-    depth: number = 2
-): OpenApiSchema {
-    if (depth <= 0) {
-        return { type: 'object', properties: {} };
-    }
-
-    const columns = getColumnMap(target);
-    const properties: Record<string, OpenApiSchema> = {};
-
-    for (const [key, col] of Object.entries(columns)) {
-        properties[key] = columnToOpenApiSchema(col);
-    }
-
-    const tableDef = target as TableDef;
-    if (tableDef.relations) {
-        for (const [relationName, relation] of Object.entries(tableDef.relations)) {
-            properties[relationName] = relationFilterToOpenApiSchema(relation);
-
-            if (depth > 1) {
-                if (relation.type === RelationKinds.BelongsTo || relation.type === RelationKinds.HasOne) {
-                    properties[relationName] = singleRelationFilterToOpenApiSchema((relation as BelongsToRelation | HasOneRelation).target);
-                } else if (relation.type === RelationKinds.HasMany || relation.type === RelationKinds.BelongsToMany) {
-                    properties[relationName] = {
-                        type: 'object',
-                        properties: {
-                            some: nestedWhereInputToOpenApiSchema((relation as HasManyRelation | BelongsToManyRelation).target, depth - 1),
-                            every: nestedWhereInputToOpenApiSchema((relation as HasManyRelation | BelongsToManyRelation).target, depth - 1),
-                        },
-                    };
-                }
-            }
-        }
-    }
-
-    return {
-        type: 'object',
-        properties,
-    };
-}
+import type { TableDef } from '../../../schema/table.js';
+import type { EntityConstructor } from '../../../orm/entity-metadata.js';
+import {
+    RelationDef,
+    BelongsToRelation,
+    HasManyRelation,
+    HasOneRelation,
+    BelongsToManyRelation,
+    RelationKinds
+} from '../../../schema/relation.js';
+import type { OpenApiSchema, OpenApiDialect } from '../types.js';
+import { columnToFilterSchema } from './filter.js';
+import { getColumnMap } from './base.js';
+
+export function relationFilterToOpenApiSchema(
+    relation: RelationDef,
+    options?: {
+        exclude?: string[];
+        include?: string[];
+    },
+    dialect: OpenApiDialect = 'openapi-3.1',
+    depth: number = 0
+): OpenApiSchema {
+    if (relation.type === RelationKinds.BelongsTo || relation.type === RelationKinds.HasOne) {
+        return singleRelationFilterToOpenApiSchema(
+            (relation as BelongsToRelation | HasOneRelation).target,
+            options,
+            dialect,
+            depth
+        );
+    }
+
+    if (relation.type === RelationKinds.HasMany || relation.type === RelationKinds.BelongsToMany) {
+        return manyRelationFilterToOpenApiSchema(
+            (relation as HasManyRelation | BelongsToManyRelation).target,
+            options,
+            dialect,
+            depth
+        );
+    }
+
+    return { type: 'object', properties: {} };
+}
+
+function singleRelationFilterToOpenApiSchema(
+    target: TableDef | EntityConstructor,
+    options?: { exclude?: string[]; include?: string[] },
+    dialect: OpenApiDialect = 'openapi-3.1',
+    depth: number = 0
+): OpenApiSchema {
+    const columns = getColumnMap(target);
+    const properties: Record<string, OpenApiSchema> = {};
+    const required: string[] = [];
+
+    for (const [key, col] of Object.entries(columns)) {
+        if (options?.exclude?.includes(key)) {
+            continue;
+        }
+
+        if (options?.include && !options.include.includes(key)) {
+            continue;
+        }
+
+        properties[key] = columnToFilterSchema(col, dialect);
+
+        if (col.notNull || col.primary) {
+            required.push(key);
+        }
+    }
+
+    if (depth > 0) {
+        const tableDef = target as TableDef;
+        if (tableDef.relations) {
+            for (const [relationName, relation] of Object.entries(tableDef.relations)) {
+                properties[relationName] = relationFilterToOpenApiSchema(relation, undefined, dialect, depth - 1);
+            }
+        }
+    }
+
+    return {
+        type: 'object',
+        properties,
+        ...(required.length > 0 && { required }),
+    };
+}
+
+function manyRelationFilterToOpenApiSchema(
+    target: TableDef | EntityConstructor,
+    options?: { exclude?: string[]; include?: string[] },
+    dialect: OpenApiDialect = 'openapi-3.1',
+    depth: number = 0
+): OpenApiSchema {
+    const nestedSchema: OpenApiSchema = depth > 0
+        ? nestedWhereInputToOpenApiSchema(target, depth, dialect)
+        : {
+            type: 'object',
+            properties: generateNestedProperties(target, options, dialect),
+        };
+
+    return {
+        type: 'object',
+        properties: {
+            some: {
+                ...nestedSchema,
+                description: 'Filter related records that match all conditions',
+            },
+            every: {
+                ...nestedSchema,
+                description: 'Filter related records where all match conditions',
+            },
+            none: {
+                ...nestedSchema,
+                description: 'Filter where no related records match',
+            },
+            isEmpty: {
+                type: 'boolean',
+                description: 'Filter where relation has no related records',
+            },
+            isNotEmpty: {
+                type: 'boolean',
+                description: 'Filter where relation has related records',
+            },
+        },
+    };
+}
+
+function generateNestedProperties(
+    target: TableDef | EntityConstructor,
+    options?: { exclude?: string[]; include?: string[] },
+    dialect: OpenApiDialect = 'openapi-3.1'
+): Record<string, OpenApiSchema> {
+    const columns = getColumnMap(target);
+    const properties: Record<string, OpenApiSchema> = {};
+
+    for (const [key, col] of Object.entries(columns)) {
+        if (options?.exclude?.includes(key)) {
+            continue;
+        }
+
+        if (options?.include && !options.include.includes(key)) {
+            continue;
+        }
+
+        properties[key] = columnToFilterSchema(col, dialect);
+    }
+
+    return properties;
+}
+
+export function whereInputWithRelationsToOpenApiSchema<T extends TableDef | EntityConstructor>(
+    target: T,
+    options?: {
+        columnExclude?: string[];
+        columnInclude?: string[];
+        relationExclude?: string[];
+        relationInclude?: string[];
+        maxDepth?: number;
+    },
+    dialect: OpenApiDialect = 'openapi-3.1'
+): OpenApiSchema {
+    const columns = getColumnMap(target);
+    const properties: Record<string, OpenApiSchema> = {};
+    const depth = options?.maxDepth ?? 3;
+
+    for (const [key, col] of Object.entries(columns)) {
+        if (options?.columnExclude?.includes(key)) {
+            continue;
+        }
+
+        if (options?.columnInclude && !options.columnInclude.includes(key)) {
+            continue;
+        }
+
+        properties[key] = columnToFilterSchema(col, dialect);
+    }
+
+    const tableDef = target as TableDef;
+    if (tableDef.relations && depth > 0) {
+        for (const [relationName, relation] of Object.entries(tableDef.relations)) {
+            if (options?.relationExclude?.includes(relationName)) {
+                continue;
+            }
+
+            if (options?.relationInclude && !options.relationInclude.includes(relationName)) {
+                continue;
+            }
+
+            properties[relationName] = relationFilterToOpenApiSchema(relation, {
+                exclude: options?.columnExclude,
+                include: options?.columnInclude,
+            }, dialect);
+        }
+    }
+
+    return {
+        type: 'object',
+        properties,
+    };
+}
+
+export function nestedWhereInputToOpenApiSchema<T extends TableDef | EntityConstructor>(
+    target: T,
+    depth: number = 2,
+    dialect: OpenApiDialect = 'openapi-3.1'
+): OpenApiSchema {
+    if (depth <= 0) {
+        return { type: 'object', properties: {} };
+    }
+
+    const columns = getColumnMap(target);
+    const properties: Record<string, OpenApiSchema> = {};
+
+    for (const [key, col] of Object.entries(columns)) {
+        properties[key] = columnToFilterSchema(col, dialect);
+    }
+
+    const tableDef = target as TableDef;
+    if (tableDef.relations) {
+        for (const [relationName, relation] of Object.entries(tableDef.relations)) {
+            properties[relationName] = relationFilterToOpenApiSchema(relation, undefined, dialect, depth - 1);
+        }
+    }
+
+    return {
+        type: 'object',
+        properties,
+    };
+}