metal-orm 1.0.91 → 1.0.93

package/dist/index.cjs

@@ -91,6 +91,7 @@ __export(index_exports, {
   aliasRef: () => aliasRef,
   and: () => and,
   applyFilter: () => applyFilter,
+  applyNullability: () => applyNullability,
   arrayAppend: () => arrayAppend,
   asType: () => asType,
   ascii: () => ascii,
@@ -108,6 +109,7 @@ __export(index_exports, {
   bootstrapEntities: () => bootstrapEntities,
   buildFilterExpression: () => buildFilterExpression,
   calculateTotalPages: () => calculateTotalPages,
+  canonicalizeSchema: () => canonicalizeSchema,
   caseWhen: () => caseWhen,
   cast: () => cast,
   cbrt: () => cbrt,
@@ -122,10 +124,12 @@ __export(index_exports, {
   col: () => col,
   collate: () => collate,
   columnOperand: () => columnOperand,
+  columnToFilterSchema: () => columnToFilterSchema,
   columnToOpenApiSchema: () => columnToOpenApiSchema,
   columnTypeToOpenApiFormat: () => columnTypeToOpenApiFormat,
   columnTypeToOpenApiType: () => columnTypeToOpenApiType,
   computePaginationMetadata: () => computePaginationMetadata,
+  computeSchemaHash: () => computeSchemaHash,
   concat: () => concat,
   concatWs: () => concatWs,
   correlateBy: () => correlateBy,
@@ -134,6 +138,7 @@ __export(index_exports, {
   count: () => count,
   countAll: () => countAll,
   createApiComponentsSection: () => createApiComponentsSection,
+  createDeterministicNamingState: () => createDeterministicNamingState,
   createDtoToOpenApiSchema: () => createDtoToOpenApiSchema,
   createEntityFromRow: () => createEntityFromRow,
   createEntityProxy: () => createEntityProxy,
@@ -192,6 +197,8 @@ __export(index_exports, {
   getColumn: () => getColumn,
   getColumnMap: () => getColumnMap,
   getDecoratorMetadata: () => getDecoratorMetadata,
+  getDeterministicComponentName: () => getDeterministicComponentName,
+  getOpenApiVersionForDialect: () => getOpenApiVersionForDialect,
   getSchemaIntrospector: () => getSchemaIntrospector,
   getTableDefFromEntity: () => getTableDefFromEntity,
   greatest: () => greatest,
@@ -219,6 +226,7 @@ __export(index_exports, {
   isFunctionNode: () => isFunctionNode,
   isNotNull: () => isNotNull,
   isNull: () => isNull,
+  isNullableColumn: () => isNullableColumn,
   isOperandNode: () => isOperandNode,
   isTableDef: () => isTableDef2,
   isValueOperandInput: () => isValueOperandInput,
@@ -6512,7 +6520,7 @@ var buildTableDef = (meta) => {
   for (const [key, def] of Object.entries(meta.columns)) {
     columns[key] = {
       ...def,
-      name: key,
+      name: def.name ?? key,
       table: meta.tableName
     };
   }
@@ -12690,7 +12698,8 @@ var normalizeColumnInput = (input) => {
     generated: asDefinition.generated,
     check: asDefinition.check,
     references: asDefinition.references,
-    comment: asDefinition.comment
+    comment: asDefinition.comment,
+    name: asOptions.name ?? asDefinition.name
   };
   if (!column.type) {
     throw new Error("Column decorator requires a column type");
@@ -13737,7 +13746,38 @@ function mergeSchemas(base, override) {
     required: override.required ?? base.required
   };
 }
-function generateOpenApiDocument(info, routes) {
+function applyNullability(schema, isNullable, dialect) {
+  if (!isNullable) {
+    const { nullable: _2, ...clean2 } = schema;
+    return clean2;
+  }
+  if (dialect === "openapi-3.0") {
+    return { ...schema, nullable: true };
+  }
+  const type = schema.type;
+  if (Array.isArray(type)) {
+    if (!type.includes("null")) {
+      const { nullable: _2, ...clean2 } = schema;
+      return { ...clean2, type: [...type, "null"] };
+    }
+  } else if (type) {
+    const { nullable: _2, ...clean2 } = schema;
+    return { ...clean2, type: [type, "null"] };
+  } else {
+    const { nullable: _2, ...clean2 } = schema;
+    return { ...clean2, type: ["null"] };
+  }
+  const { nullable: _, ...clean } = schema;
+  return clean;
+}
+function isNullableColumn(col2) {
+  return !col2.notNull;
+}
+function getOpenApiVersionForDialect(dialect) {
+  return dialect === "openapi-3.0" ? "3.0.3" : "3.1.0";
+}
+function generateOpenApiDocument(info, routes, options) {
+  const dialect = options?.dialect ?? "openapi-3.1";
   const paths = {};
   for (const route of routes) {
     if (!paths[route.path]) {
@@ -13746,7 +13786,7 @@ function generateOpenApiDocument(info, routes) {
     paths[route.path][route.method] = route.operation;
   }
   return {
-    openapi: "3.1.0",
+    openapi: getOpenApiVersionForDialect(dialect),
     info: {
       title: info.title,
       version: info.version,
@@ -13780,34 +13820,33 @@ function getColumnMap(target) {
 }
 
 // src/dto/openapi/generators/column.ts
-function columnToOpenApiSchema(col2) {
+function columnToOpenApiSchema(col2, dialect = "openapi-3.1") {
   const schema = {
     type: columnTypeToOpenApiType(col2),
     format: columnTypeToOpenApiFormat(col2)
   };
-  if (!col2.notNull) {
-    schema.nullable = true;
-  }
+  const nullable = isNullableColumn(col2);
+  const result = applyNullability(schema, nullable, dialect);
   if (col2.comment) {
-    schema.description = col2.comment;
+    result.description = col2.comment;
   }
   if (col2.type.toUpperCase() === "ENUM" && col2.args && Array.isArray(col2.args) && col2.args.every((v) => typeof v === "string")) {
-    schema.enum = col2.args;
+    result.enum = col2.args;
   }
   const args = col2.args;
   if (args && args.length > 0) {
     if (col2.type.toUpperCase() === "VARCHAR" || col2.type.toUpperCase() === "CHAR") {
       const length2 = args[0];
       if (length2) {
-        schema.example = "a".repeat(length2);
+        result.example = "a".repeat(length2);
       }
     }
   }
-  return schema;
+  return result;
 }
 
 // src/dto/openapi/generators/dto.ts
-function dtoToOpenApiSchema(target, exclude2) {
+function dtoToOpenApiSchema(target, exclude2, dialect = "openapi-3.1") {
   const columns = getColumnMap(target);
   const properties = {};
   const required = [];
@@ -13815,7 +13854,7 @@ function dtoToOpenApiSchema(target, exclude2) {
     if (exclude2?.includes(key)) {
       continue;
     }
-    properties[key] = columnToOpenApiSchema(col2);
+    properties[key] = columnToOpenApiSchema(col2, dialect);
     if (col2.notNull || col2.primary) {
       required.push(key);
     }
@@ -13826,7 +13865,7 @@ function dtoToOpenApiSchema(target, exclude2) {
     ...required.length > 0 && { required }
   };
 }
-function createDtoToOpenApiSchema(target, exclude2) {
+function createDtoToOpenApiSchema(target, exclude2, dialect = "openapi-3.1") {
   const columns = getColumnMap(target);
   const properties = {};
   const required = [];
@@ -13837,7 +13876,7 @@ function createDtoToOpenApiSchema(target, exclude2) {
     if (col2.autoIncrement || col2.generated) {
       continue;
     }
-    properties[key] = columnToOpenApiSchema(col2);
+    properties[key] = columnToOpenApiSchema(col2, dialect);
     if (col2.notNull && !col2.default) {
       required.push(key);
     }
@@ -13848,7 +13887,7 @@ function createDtoToOpenApiSchema(target, exclude2) {
     ...required.length > 0 && { required }
   };
 }
-function updateDtoToOpenApiSchema(target, exclude2) {
+function updateDtoToOpenApiSchema(target, exclude2, dialect = "openapi-3.1") {
   const columns = getColumnMap(target);
   const properties = {};
   for (const [key, col2] of Object.entries(columns)) {
@@ -13858,10 +13897,7 @@ function updateDtoToOpenApiSchema(target, exclude2) {
     if (col2.autoIncrement || col2.generated) {
       continue;
     }
-    properties[key] = {
-      ...columnToOpenApiSchema(col2),
-      ...!col2.notNull ? { nullable: true } : {}
-    };
+    properties[key] = columnToOpenApiSchema(col2, dialect);
   }
   return {
     type: "object",
@@ -13871,58 +13907,49 @@ function updateDtoToOpenApiSchema(target, exclude2) {
 
 // src/dto/openapi/generators/filter.ts
 function filterFieldToOpenApiSchema(col2) {
-  const normalizedType = col2.type.toUpperCase();
-  columnTypeToOpenApiType(col2);
-  let filterProperties = {};
-  if (["INT", "INTEGER", "BIGINT", "DECIMAL", "FLOAT", "DOUBLE"].includes(normalizedType)) {
-    filterProperties = {
-      equals: { type: "number" },
-      not: { type: "number" },
-      in: { type: "array", items: { type: "number" } },
-      notIn: { type: "array", items: { type: "number" } },
-      lt: { type: "number" },
-      lte: { type: "number" },
-      gt: { type: "number" },
-      gte: { type: "number" }
-    };
-  } else if (["BOOLEAN"].includes(normalizedType)) {
-    filterProperties = {
-      equals: { type: "boolean" },
-      not: { type: "boolean" }
-    };
-  } else if (["DATE", "DATETIME", "TIMESTAMP", "TIMESTAMPTZ"].includes(normalizedType)) {
-    filterProperties = {
-      equals: { type: "string", format: "date-time" },
-      not: { type: "string", format: "date-time" },
-      in: { type: "array", items: { type: "string", format: "date-time" } },
-      notIn: { type: "array", items: { type: "string", format: "date-time" } },
-      lt: { type: "string", format: "date-time" },
-      lte: { type: "string", format: "date-time" },
-      gt: { type: "string", format: "date-time" },
-      gte: { type: "string", format: "date-time" }
-    };
-  } else {
-    filterProperties = {
-      equals: { type: "string" },
-      not: { type: "string" },
-      in: { type: "array", items: { type: "string" } },
-      notIn: { type: "array", items: { type: "string" } },
-      contains: { type: "string" },
-      startsWith: { type: "string" },
-      endsWith: { type: "string" },
-      mode: { type: "string", enum: ["default", "insensitive"] }
-    };
+  const openApiType = columnTypeToOpenApiType(col2);
+  const openApiFormat = columnTypeToOpenApiFormat(col2);
+  const filterProperties = {};
+  filterProperties.equals = { type: openApiType, format: openApiFormat };
+  filterProperties.not = { type: openApiType, format: openApiFormat };
+  filterProperties.in = { type: "array", items: { type: openApiType, format: openApiFormat } };
+  filterProperties.notIn = { type: "array", items: { type: openApiType, format: openApiFormat } };
+  const isNumeric = openApiType === "integer" || openApiType === "number";
+  const isDateOrTime = openApiType === "string" && (openApiFormat === "date" || openApiFormat === "date-time");
+  const isString = openApiType === "string" && !isDateOrTime;
+  if (isNumeric) {
+    filterProperties.lt = { type: openApiType, format: openApiFormat };
+    filterProperties.lte = { type: openApiType, format: openApiFormat };
+    filterProperties.gt = { type: openApiType, format: openApiFormat };
+    filterProperties.gte = { type: openApiType, format: openApiFormat };
+  }
+  if (isDateOrTime) {
+    filterProperties.lt = { type: openApiType, format: openApiFormat };
+    filterProperties.lte = { type: openApiType, format: openApiFormat };
+    filterProperties.gt = { type: openApiType, format: openApiFormat };
+    filterProperties.gte = { type: openApiType, format: openApiFormat };
+  }
+  if (isString) {
+    filterProperties.contains = { type: "string" };
+    filterProperties.startsWith = { type: "string" };
+    filterProperties.endsWith = { type: "string" };
+    filterProperties.mode = { type: "string", enum: ["default", "insensitive"] };
   }
   return {
     type: "object",
     properties: filterProperties
   };
 }
-function whereInputToOpenApiSchema(target) {
+function columnToFilterSchema(col2, dialect = "openapi-3.1") {
+  const filterSchema = filterFieldToOpenApiSchema(col2);
+  const nullable = isNullableColumn(col2);
+  return applyNullability(filterSchema, nullable, dialect);
+}
+function whereInputToOpenApiSchema(target, dialect = "openapi-3.1") {
   const columns = getColumnMap(target);
   const properties = {};
   for (const [key, col2] of Object.entries(columns)) {
-    properties[key] = filterFieldToOpenApiSchema(col2);
+    properties[key] = columnToFilterSchema(col2, dialect);
   }
   return {
     type: "object",
@@ -13931,16 +13958,26 @@ function whereInputToOpenApiSchema(target) {
 }
 
 // src/dto/openapi/generators/relation-filter.ts
-function relationFilterToOpenApiSchema(relation, options) {
+function relationFilterToOpenApiSchema(relation, options, dialect = "openapi-3.1", depth = 0) {
   if (relation.type === RelationKinds.BelongsTo || relation.type === RelationKinds.HasOne) {
-    return singleRelationFilterToOpenApiSchema(relation.target, options);
+    return singleRelationFilterToOpenApiSchema(
+      relation.target,
+      options,
+      dialect,
+      depth
+    );
   }
   if (relation.type === RelationKinds.HasMany || relation.type === RelationKinds.BelongsToMany) {
-    return manyRelationFilterToOpenApiSchema(relation.target, options);
+    return manyRelationFilterToOpenApiSchema(
+      relation.target,
+      options,
+      dialect,
+      depth
+    );
   }
   return { type: "object", properties: {} };
 }
-function singleRelationFilterToOpenApiSchema(target, options) {
+function singleRelationFilterToOpenApiSchema(target, options, dialect = "openapi-3.1", depth = 0) {
   const columns = getColumnMap(target);
   const properties = {};
   const required = [];
@@ -13951,35 +13988,44 @@ function singleRelationFilterToOpenApiSchema(target, options) {
     if (options?.include && !options.include.includes(key)) {
       continue;
     }
-    properties[key] = columnToOpenApiSchema(col2);
+    properties[key] = columnToFilterSchema(col2, dialect);
     if (col2.notNull || col2.primary) {
       required.push(key);
     }
   }
+  if (depth > 0) {
+    const tableDef = target;
+    if (tableDef.relations) {
+      for (const [relationName, relation] of Object.entries(tableDef.relations)) {
+        properties[relationName] = relationFilterToOpenApiSchema(relation, void 0, dialect, depth - 1);
+      }
+    }
+  }
   return {
     type: "object",
     properties,
     ...required.length > 0 && { required }
   };
 }
-function manyRelationFilterToOpenApiSchema(target, options) {
+function manyRelationFilterToOpenApiSchema(target, options, dialect = "openapi-3.1", depth = 0) {
+  const nestedSchema = depth > 0 ? nestedWhereInputToOpenApiSchema(target, depth, dialect) : {
+    type: "object",
+    properties: generateNestedProperties(target, options, dialect)
+  };
   return {
     type: "object",
     properties: {
       some: {
-        type: "object",
-        description: "Filter related records that match all conditions",
-        properties: generateNestedProperties(target, options)
+        ...nestedSchema,
+        description: "Filter related records that match all conditions"
       },
       every: {
-        type: "object",
-        description: "Filter related records where all match conditions",
-        properties: generateNestedProperties(target, options)
+        ...nestedSchema,
+        description: "Filter related records where all match conditions"
       },
       none: {
-        type: "object",
-        description: "Filter where no related records match",
-        properties: generateNestedProperties(target, options)
+        ...nestedSchema,
+        description: "Filter where no related records match"
       },
       isEmpty: {
         type: "boolean",
@@ -13992,7 +14038,7 @@ function manyRelationFilterToOpenApiSchema(target, options) {
     }
   };
 }
-function generateNestedProperties(target, options) {
+function generateNestedProperties(target, options, dialect = "openapi-3.1") {
   const columns = getColumnMap(target);
   const properties = {};
   for (const [key, col2] of Object.entries(columns)) {
@@ -14002,11 +14048,11 @@ function generateNestedProperties(target, options) {
     if (options?.include && !options.include.includes(key)) {
       continue;
     }
-    properties[key] = columnToOpenApiSchema(col2);
+    properties[key] = columnToFilterSchema(col2, dialect);
   }
   return properties;
 }
-function whereInputWithRelationsToOpenApiSchema(target, options) {
+function whereInputWithRelationsToOpenApiSchema(target, options, dialect = "openapi-3.1") {
   const columns = getColumnMap(target);
   const properties = {};
   const depth = options?.maxDepth ?? 3;
@@ -14017,7 +14063,7 @@ function whereInputWithRelationsToOpenApiSchema(target, options) {
     if (options?.columnInclude && !options.columnInclude.includes(key)) {
       continue;
     }
-    properties[key] = columnToOpenApiSchema(col2);
+    properties[key] = columnToFilterSchema(col2, dialect);
   }
   const tableDef = target;
   if (tableDef.relations && depth > 0) {
@@ -14031,7 +14077,7 @@ function whereInputWithRelationsToOpenApiSchema(target, options) {
       properties[relationName] = relationFilterToOpenApiSchema(relation, {
         exclude: options?.columnExclude,
         include: options?.columnInclude
-      });
+      }, dialect);
     }
   }
   return {
@@ -14039,32 +14085,19 @@ function whereInputWithRelationsToOpenApiSchema(target, options) {
     properties
   };
 }
-function nestedWhereInputToOpenApiSchema(target, depth = 2) {
+function nestedWhereInputToOpenApiSchema(target, depth = 2, dialect = "openapi-3.1") {
   if (depth <= 0) {
     return { type: "object", properties: {} };
   }
   const columns = getColumnMap(target);
   const properties = {};
   for (const [key, col2] of Object.entries(columns)) {
-    properties[key] = columnToOpenApiSchema(col2);
+    properties[key] = columnToFilterSchema(col2, dialect);
   }
   const tableDef = target;
   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.target);
-        } else if (relation.type === RelationKinds.HasMany || relation.type === RelationKinds.BelongsToMany) {
-          properties[relationName] = {
-            type: "object",
-            properties: {
-              some: nestedWhereInputToOpenApiSchema(relation.target, depth - 1),
-              every: nestedWhereInputToOpenApiSchema(relation.target, depth - 1)
-            }
-          };
-        }
-      }
+      properties[relationName] = relationFilterToOpenApiSchema(relation, void 0, dialect, depth - 1);
     }
   }
   return {
@@ -14138,10 +14171,7 @@ function updateDtoWithRelationsToOpenApiSchema(target, _options) {
     if (col2.autoIncrement || col2.generated) {
       continue;
     }
-    properties[key] = {
-      ...columnToOpenApiSchema(col2),
-      nullable: true
-    };
+    properties[key] = columnToOpenApiSchema(col2);
   }
   const tableDef = target;
   if (_options?.includeRelations !== false && tableDef.relations) {
@@ -14165,10 +14195,7 @@ function updateDtoToOpenApiSchemaForComponent(target) {
     if (col2.autoIncrement || col2.generated) {
       continue;
     }
-    properties[key] = {
-      ...columnToOpenApiSchema(col2),
-      nullable: true
-    };
+    properties[key] = columnToOpenApiSchema(col2);
   }
   return {
     type: "object",
@@ -14238,7 +14265,7 @@ function createDtoToOpenApiSchemaForComponent(target) {
     properties
   };
 }
-function whereInputWithRelationsToOpenApiSchema2(target, options) {
+function whereInputWithRelationsToOpenApiSchema2(target, options, dialect = "openapi-3.1") {
   const columns = getColumnMap(target);
   const properties = {};
   const depth = options?.maxDepth ?? 3;
@@ -14249,7 +14276,7 @@ function whereInputWithRelationsToOpenApiSchema2(target, options) {
     if (options?.columnInclude && !options.columnInclude.includes(key)) {
       continue;
     }
-    properties[key] = columnToOpenApiSchema(col2);
+    properties[key] = columnToFilterSchema(col2, dialect);
   }
   const tableDef = target;
   if (tableDef.relations && depth > 0) {
@@ -14261,9 +14288,9 @@ function whereInputWithRelationsToOpenApiSchema2(target, options) {
         continue;
       }
       properties[relationName] = relationFilterToOpenApiSchema2(relation, {
-        exclude: options?.columnExclude,
-        include: options?.columnInclude
-      });
+        exclude: options.columnExclude,
+        include: options.columnInclude
+      }, dialect);
     }
   }
   return {
@@ -14271,16 +14298,16 @@ function whereInputWithRelationsToOpenApiSchema2(target, options) {
     properties
   };
 }
-function relationFilterToOpenApiSchema2(relation, options) {
+function relationFilterToOpenApiSchema2(relation, options, dialect = "openapi-3.1") {
   if (relation.type === RelationKinds.BelongsTo || relation.type === RelationKinds.HasOne) {
-    return singleRelationFilterToOpenApiSchema2(relation.target, options);
+    return singleRelationFilterToOpenApiSchema2(relation.target, options, dialect);
   }
   if (relation.type === RelationKinds.HasMany || relation.type === RelationKinds.BelongsToMany) {
     return manyRelationFilterToOpenApiSchema2(relation.target);
   }
   return { type: "object", properties: {} };
 }
-function singleRelationFilterToOpenApiSchema2(target, options) {
+function singleRelationFilterToOpenApiSchema2(target, options, dialect = "openapi-3.1") {
   const columns = getColumnMap(target);
   const properties = {};
   for (const [key, col2] of Object.entries(columns)) {
@@ -14290,7 +14317,7 @@ function singleRelationFilterToOpenApiSchema2(target, options) {
     if (options?.include && !options.include.includes(key)) {
       continue;
     }
-    properties[key] = columnToOpenApiSchema(col2);
+    properties[key] = columnToFilterSchema(col2, dialect);
   }
   return {
     type: "object",
@@ -14331,7 +14358,7 @@ function generateNestedProperties2(target) {
   const columns = getColumnMap(target);
   const properties = {};
   for (const [key, col2] of Object.entries(columns)) {
-    properties[key] = columnToOpenApiSchema(col2);
+    properties[key] = columnToFilterSchema(col2);
   }
   return properties;
 }
@@ -14360,6 +14387,67 @@ function parameterToRef(paramName) {
 function responseToRef(responseName) {
   return createRef(`responses/${responseName}`);
 }
+function canonicalizeSchema(schema) {
+  if (typeof schema !== "object" || schema === null) {
+    return schema;
+  }
+  if (Array.isArray(schema)) {
+    return schema.map(canonicalizeSchema);
+  }
+  const canonical = {};
+  const keys = Object.keys(schema).sort();
+  for (const key of keys) {
+    if (key === "description" || key === "example") {
+      continue;
+    }
+    const value = schema[key];
+    if (typeof value === "object" && value !== null) {
+      canonical[key] = canonicalizeSchema(value);
+    } else {
+      canonical[key] = value;
+    }
+  }
+  return canonical;
+}
+function computeSchemaHash(schema) {
+  const canonical = canonicalizeSchema(schema);
+  const json = JSON.stringify(canonical);
+  let hash = 0;
+  for (let i = 0; i < json.length; i++) {
+    const char2 = json.charCodeAt(i);
+    hash = (hash << 5) - hash + char2;
+    hash = hash & hash;
+  }
+  const hex = Math.abs(hash).toString(16);
+  return hex.padStart(8, "0").slice(0, 6);
+}
+function createDeterministicNamingState() {
+  return {
+    contentHashToName: /* @__PURE__ */ new Map(),
+    nameToContentHash: /* @__PURE__ */ new Map()
+  };
+}
+function getDeterministicComponentName(baseName, schema, state) {
+  const hash = computeSchemaHash(schema);
+  const normalizedBase = baseName.replace(/[^A-Za-z0-9_]/g, "");
+  const existingName = state.contentHashToName.get(hash);
+  if (existingName) {
+    return existingName;
+  }
+  if (!state.nameToContentHash.has(normalizedBase)) {
+    state.contentHashToName.set(hash, normalizedBase);
+    state.nameToContentHash.set(normalizedBase, hash);
+    return normalizedBase;
+  }
+  const existingHash = state.nameToContentHash.get(normalizedBase);
+  if (existingHash === hash) {
+    return normalizedBase;
+  }
+  const uniqueName = `${normalizedBase}_${hash}`;
+  state.contentHashToName.set(hash, uniqueName);
+  state.nameToContentHash.set(uniqueName, hash);
+  return uniqueName;
+}
 function replaceWithRefs(schema, schemaMap, path = "components/schemas") {
   if (typeof schema === "object" && schema !== null) {
     if ("$ref" in schema) {
@@ -14581,6 +14669,7 @@ function pagedResponseToOpenApiSchema(itemSchema) {
   aliasRef,
   and,
   applyFilter,
+  applyNullability,
   arrayAppend,
   asType,
   ascii,
@@ -14598,6 +14687,7 @@ function pagedResponseToOpenApiSchema(itemSchema) {
   bootstrapEntities,
   buildFilterExpression,
   calculateTotalPages,
+  canonicalizeSchema,
   caseWhen,
   cast,
   cbrt,
@@ -14612,10 +14702,12 @@ function pagedResponseToOpenApiSchema(itemSchema) {
   col,
   collate,
   columnOperand,
+  columnToFilterSchema,
   columnToOpenApiSchema,
   columnTypeToOpenApiFormat,
   columnTypeToOpenApiType,
   computePaginationMetadata,
+  computeSchemaHash,
   concat,
   concatWs,
   correlateBy,
@@ -14624,6 +14716,7 @@ function pagedResponseToOpenApiSchema(itemSchema) {
   count,
   countAll,
   createApiComponentsSection,
+  createDeterministicNamingState,
   createDtoToOpenApiSchema,
   createEntityFromRow,
   createEntityProxy,
@@ -14682,6 +14775,8 @@ function pagedResponseToOpenApiSchema(itemSchema) {
   getColumn,
   getColumnMap,
   getDecoratorMetadata,
+  getDeterministicComponentName,
+  getOpenApiVersionForDialect,
   getSchemaIntrospector,
   getTableDefFromEntity,
   greatest,
@@ -14709,6 +14804,7 @@ function pagedResponseToOpenApiSchema(itemSchema) {
   isFunctionNode,
   isNotNull,
   isNull,
+  isNullableColumn,
   isOperandNode,
   isTableDef,
   isValueOperandInput,