@ditojs/server 2.0.5 → 2.1.0

package/types/index.d.ts

@@ -6,28 +6,27 @@
 // Export the entire Dito namespace.
 
 import { ObjectCannedACL, S3ClientConfig } from '@aws-sdk/client-s3'
-import { DateFormat } from '@dito/utils'
-import koaCors from '@koa/cors'
+import { DateFormat } from '@ditojs/utils'
+import { Options as KoaCorsOptions } from '@koa/cors'
 import * as Ajv from 'ajv/dist/2020.js'
+import { AsyncLocalStorage } from 'async_hooks'
 import * as dbErrors from 'db-errors'
 import * as EventEmitter2 from 'eventemitter2'
 import helmet from 'helmet'
-import * as Knex from 'knex'
+import { Knex } from 'knex'
 import * as Koa from 'koa'
-import koaBodyParser from 'koa-bodyparser'
-import koaCompress from 'koa-compress'
-import koaLogger from 'koa-logger'
-import mount from 'koa-mount'
-import koaPinoLogger from 'koa-pino-logger'
+import { Options as KoaBodyParserOptions } from 'koa-bodyparser'
+import { CompressOptions } from 'koa-compress'
+import koaMount from 'koa-mount'
 import koaResponseTime from 'koa-response-time'
 import koaSession from 'koa-session'
 import multerS3 from 'multer-s3'
 import * as objection from 'objection'
 import { KnexSnakeCaseMappersFactory } from 'objection'
-import { Logger } from 'pino'
+import { Logger as PinoLogger, LoggerOptions as PinoLoggerOptions } from 'pino'
+import { PrettyOptions } from 'pino-pretty'
 import {
   Class,
-  ConditionalExcept,
   ConditionalKeys,
   Constructor,
   SetOptional,
@@ -126,29 +125,29 @@ export type ApplicationConfig = {
      * @see https://github.com/helmetjs/helmet
      */
     helmet?: boolean | Parameters<typeof helmet>[0]
-    logger?:
-      | Parameters<typeof koaLogger>[0]
-      | Parameters<typeof koaPinoLogger>[0]
+    logger?: {
+      prettyPrint: PrettyOptions
+    } & PinoLoggerOptions
     /**
      * Configure body parser.
      *
      * @see https://github.com/koajs/bodyparser#options
      */
-    bodyParser?: koaBodyParser.Options
+    bodyParser?: KoaBodyParserOptions
     /**
      * Enable or configure Cross-Origin Resource Sharing (CORS)
      *
      * @defaultValue `true`
      * @see https://github.com/koajs/cors#corsoptions
      */
-    cors?: boolean | koaCors.Options
+    cors?: boolean | KoaCorsOptions
     /**
      * Enable or configure server response compression
      *
      * @defaultValue `true`
      * @see https://github.com/koajs/compress#options
      */
-    compress?: boolean | koaCompress.CompressOptions
+    compress?: boolean | CompressOptions
     /**
      * Enable ETag headers in server responses
      *
@@ -346,6 +345,11 @@ export interface ApplicationControllers {
 
 export type Models = Record<string, Class<Model>>
 
+interface AsyncRequestLocals {
+  transaction: objection.Transaction
+  logger: PinoLogger
+}
+
 export class Application<$Models extends Models = Models> {
   constructor(options: {
     config?: ApplicationConfig
@@ -382,8 +386,11 @@ export class Application<$Models extends Models = Models> {
   addControllers(controllers: ApplicationControllers, namespace?: string): void
   setupControllers(): Promise<void>
   getAdminViteConfig(config?: UserConfig): UserConfig
-  logger: Logger
+  logger: PinoLogger
+  requestStorage: AsyncLocalStorage<AsyncRequestLocals>
+  requestLocals: AsyncRequestLocals
 }
+
 export interface Application
   extends Omit<
       Koa,
@@ -608,7 +615,8 @@ export type ModelHooks<$Model extends Model = Model> = {
     | 'find'
     | 'insert'
     | 'update'
-    | 'delete'}`]?: ModelHookFunction<$Model>
+    | 'delete'
+  }`]?: ModelHookFunction<$Model>
 }
 
 export class Model extends objection.Model {
@@ -686,8 +694,6 @@ export class Model extends objection.Model {
   static clearWithScope: StaticQueryBuilderMethod<'clearWithScope'>
 
   static clear: StaticQueryBuilderMethod<'clear'>
-  static pick: StaticQueryBuilderMethod<'pick'>
-  static omit: StaticQueryBuilderMethod<'omit'>
   static select: StaticQueryBuilderMethod<'select'>
 
   static insert: StaticQueryBuilderMethod<'insert'>
@@ -716,26 +722,14 @@ export class Model extends objection.Model {
   static upsertDitoGraph: StaticQueryBuilderMethod<'upsertDitoGraph'>
   static updateDitoGraph: StaticQueryBuilderMethod<'updateDitoGraph'>
   static patchDitoGraph: StaticQueryBuilderMethod<'patchDitoGraph'>
-  static insertDitoGraphAndFetch:
-    StaticQueryBuilderMethod<'insertDitoGraphAndFetch'>
-
-  static upsertDitoGraphAndFetch:
-    StaticQueryBuilderMethod<'upsertDitoGraphAndFetch'>
-
-  static updateDitoGraphAndFetch:
-    StaticQueryBuilderMethod<'updateDitoGraphAndFetch'>
-
-  static patchDitoGraphAndFetch:
-    StaticQueryBuilderMethod<'patchDitoGraphAndFetch'>
-
-  static upsertDitoGraphAndFetchById:
-    StaticQueryBuilderMethod<'upsertDitoGraphAndFetchById'>
-
-  static updateDitoGraphAndFetchById:
-    StaticQueryBuilderMethod<'updateDitoGraphAndFetchById'>
 
-  static patchDitoGraphAndFetchById:
-    StaticQueryBuilderMethod<'patchDitoGraphAndFetchById'>
+  static insertDitoGraphAndFetch: StaticQueryBuilderMethod<'insertDitoGraphAndFetch'>
+  static upsertDitoGraphAndFetch: StaticQueryBuilderMethod<'upsertDitoGraphAndFetch'>
+  static updateDitoGraphAndFetch: StaticQueryBuilderMethod<'updateDitoGraphAndFetch'>
+  static patchDitoGraphAndFetch: StaticQueryBuilderMethod<'patchDitoGraphAndFetch'>
+  static upsertDitoGraphAndFetchById: StaticQueryBuilderMethod<'upsertDitoGraphAndFetchById'>
+  static updateDitoGraphAndFetchById: StaticQueryBuilderMethod<'updateDitoGraphAndFetchById'>
+  static patchDitoGraphAndFetchById: StaticQueryBuilderMethod<'patchDitoGraphAndFetchById'>
 
   static where: StaticQueryBuilderMethod<'where'>
   static whereNot: StaticQueryBuilderMethod<'whereNot'>
@@ -753,7 +747,7 @@ export class Model extends objection.Model {
   static whereNotColumn: StaticQueryBuilderMethod<'whereNotColumn'>
   static whereComposite: StaticQueryBuilderMethod<'whereComposite'>
   static whereInComposite: StaticQueryBuilderMethod<'whereInComposite'>
-  // whereNotInComposite:  QueryBuilder<Model>['whereNotInComposite']
+  static whereNotInComposite: StaticQueryBuilderMethod<'whereInComposite'> // TODO: `whereNotInComposite`
   static whereJsonHasAny: StaticQueryBuilderMethod<'whereJsonHasAny'>
   static whereJsonHasAll: StaticQueryBuilderMethod<'whereJsonHasAll'>
   static whereJsonIsArray: StaticQueryBuilderMethod<'whereJsonIsArray'>
@@ -777,17 +771,6 @@ export class Model extends objection.Model {
   static havingRaw: StaticQueryBuilderMethod<'havingRaw'>
   static havingWrapped: StaticQueryBuilderMethod<'havingWrapped'>
 
-  // deprecated methods that are still supported at the moment.
-  // TODO: Remove once we move to Objection 3.0
-
-  static eager: StaticQueryBuilderMethod<'eager'>
-  static joinEager: StaticQueryBuilderMethod<'joinEager'>
-  static naiveEager: StaticQueryBuilderMethod<'naiveEager'>
-  static mergeEager: StaticQueryBuilderMethod<'mergeEager'>
-  static mergeJoinEager: StaticQueryBuilderMethod<'mergeJoinEager'>
-  static mergeNaiveEager: StaticQueryBuilderMethod<'mergeNaiveEager'>
-  static clearEager: StaticQueryBuilderMethod<'clearEager'>
-
   // static scope:  QueryBuilder<Model>['scope']
   // static mergeScope:  QueryBuilder<Model>['mergeScope']
   // static clearScope:  QueryBuilder<Model>['clearScope']
@@ -896,7 +879,7 @@ export class Controller {
    * middleware.
    * @overridable
    */
-  compose(): Parameters<typeof mount>[1]
+  compose(): Parameters<typeof koaMount>[1]
   /** To be overridden by sub-classes. */
   getPath(type: string, path: string): string
   getUrl(type: string, path: string): string
@@ -930,10 +913,10 @@ export type ControllerActionHandler<
   $Controller extends Controller = Controller
 > = (this: $Controller, ctx: KoaContext, ...args: any[]) => any
 
-export type ExtractModelProperties<$Model> = {
-  [$Key in SelectModelPropertyKeys<$Model>]: $Model[$Key] extends Model
-    ? ExtractModelProperties<$Model[$Key]>
-    : $Model[$Key]
+export type ExtractModelProperties<$Model extends Model = Model> = {
+  [K in SelectModelPropertyKeys<$Model>]: $Model[K] extends Model
+    ? ExtractModelProperties<$Model[K]>
+    : $Model[K]
 }
 
 export type Extends<$A, $B> = $A extends $B ? 1 : 0
@@ -945,8 +928,8 @@ export type SelectModelPropertyKeys<$Model extends Model> = {
     | `$${string}`
     ? never
     : $Model[K] extends Function
-    ? never
-    : K
+      ? never
+      : K
 }[keyof $Model]
 
 export type Authorize =
@@ -1112,10 +1095,18 @@ type ModelControllerHookType = 'collection' | 'member'
 type ModelControllerHookKeys<
   $Keys extends string,
   $ModelControllerHookType extends string
-> = `${'before' | 'after' | '*'}:${$ModelControllerHookType | '*'}:${
+> = `${
+  | 'before'
+  | 'after'
+  | '*'
+}:${
+  | $ModelControllerHookType
+  | '*'
+}:${
   | Exclude<$Keys, 'allow'>
   | ControllerActionName
-  | '*'}`
+  | '*'
+}`
 type ModelControllerHook<
   $ModelController extends ModelController = ModelController
 > = (
@@ -1143,11 +1134,16 @@ type HookKeysFromController<$ModelController extends ModelController> =
 
 type HandlerFromHookKey<
   $ModelController extends ModelController,
-  $Key extends HookKeysFromController<$ModelController>
-> = $Key extends `${'before' | 'after' | '*'}:${
+  K extends HookKeysFromController<$ModelController>
+> = K extends `${
+  | 'before'
+  | 'after'
+  | '*'
+}:${
   | 'collection'
   | 'member'
-  | '*'}:${string}`
+  | '*'
+}:${string}`
   ? (this: $ModelController, ctx: KoaContext, ...args: any[]) => any
   : never
 
@@ -1441,12 +1437,13 @@ export class Service {
    * @overridable
    */
   initialize(): Promise<void>
-  /* @overridable */
+  /** @overridable */
   start(): Promise<void>
-  /* @overridable */
+  /** @overridable */
   stop(): Promise<void>
-  get logger(): Logger
-  getLogger(ctx: KoaContext): Logger
+  get logger(): PinoLogger
+  /** @deprecated Use `instance.logger` instead. */
+  getLogger(ctx: KoaContext): PinoLogger
 }
 export type Services = Record<string, Class<Service> | Service>
 
@@ -1506,7 +1503,9 @@ export class QueryBuilder<
     query: QueryParameterOptions,
     allowParam?:
       | QueryParameterOptionKey[]
-      | { [key in keyof QueryParameterOptionKey]: boolean }
+      | {
+          [key in keyof QueryParameterOptionKey]: boolean
+        }
   ) => this
 
   patchById: (id: Id, data: PartialModelObject<M>) => this
@@ -1581,10 +1580,10 @@ export type PartialModelObject<T extends Model> = {
   > extends Model
     ? T[K]
     : objection.Defined<T[K]> extends Array<infer I>
-    ? I extends Model
-      ? I[]
+      ? I extends Model
+        ? I[]
+        : objection.Expression<T[K]>
       : objection.Expression<T[K]>
-    : objection.Expression<T[K]>
 }
 
 export type PartialDitoModelGraph<M extends Partial<Model>> = {
@@ -1593,10 +1592,10 @@ export type PartialDitoModelGraph<M extends Partial<Model>> = {
   > extends Model
     ? PartialDitoModelGraph<M[K]>
     : objection.Defined<M[K]> extends Array<infer I>
-    ? I extends Partial<Model>
-      ? PartialDitoModelGraph<I>[]
+      ? I extends Partial<Model>
+        ? PartialDitoModelGraph<I>[]
+        : M[K]
       : M[K]
-    : M[K]
 }
 
 /* ------------------------------ Start Errors ----------------------------- */
@@ -1673,86 +1672,74 @@ type AssetFileObject = {
   height: number
 }
 
-export class AssetModel extends TimeStampedModel {
-  key: string
-  file: AssetFileObject
-  storage: string
-  count: number
-}
-
-export const AssetMixin: <T extends Constructor>(
+export const AssetMixin: <T extends Constructor<{}>>(
   target: T
-) => Constructor<
-  InstanceType<T> & {
+) => T &
+  Constructor<{
     key: string
     file: AssetFileObject
     storage: string
     count: number
-  }
->
+  }>
 
-export class TimeStampedModel extends Model {
-  createdAt: Date
-  updatedAt: Date
-}
+export const AssetModel: ReturnType<typeof AssetMixin<typeof Model>>
 
-export const TimeStampedMixin: <T extends Constructor>(
+export const TimeStampedMixin: <T extends Constructor<{}>>(
   target: T
-) => Constructor<InstanceType<T> & {
-  createdAt: Date
-  updatedAt: Date
-}>
-
-export class UserModel extends Model {
-  static options?: {
-    usernameProperty?: string
-    passwordProperty?: string
-    /**
-     * This option can be used to specify (eager) scopes to be applied when the
-     * user is deserialized from the session.
-     */
-    sessionScope?: OrArrayOf<string>
-  }
+) => T &
+  Constructor<{
+    createdAt: Date
+    updatedAt: Date
+  }>
 
-  username: string
-  password: string
-  hash: string
-  lastLogin?: Date
+export const TimeStampedModel: ReturnType<typeof TimeStampedMixin<typeof Model>>
 
-  $verifyPassword(password: string): Promise<boolean>
+export const SessionMixin: <T extends Constructor<{}>>(
+  target: T
+) => T &
+  Constructor<{
+    id: string
+    value: { [key: string]: any }
+  }>
 
-  $hasRole(...roles: string[]): boolean
+export const SessionModel: ReturnType<typeof SessionMixin<typeof Model>>
 
-  $hasOwner(owner: UserModel): boolean
+export const UserMixin: <T extends Constructor<{}>>(
+  target: T
+) => T &
+  Constructor<{
+    username: string
+    password: string
+    hash: string
+    lastLogin?: Date
 
-  $isLoggedIn(ctx: KoaContext): boolean
+    $verifyPassword(password: string): Promise<boolean>
 
-  // TODO: type options
-  static login(ctx: KoaContext, options: any): Promise<void>
+    $hasRole(...roles: string[]): boolean
 
-  static sessionQuery(trx: Knex.Transaction): QueryBuilder<UserModel>
-}
+    $hasOwner(owner: InstanceType<typeof UserModel>): boolean
 
-export class SessionModel extends Model {
-  id: string
-  value: { [key: string]: any }
-}
+    $isLoggedIn(ctx: KoaContext): boolean
+  }> & {
+    options?: {
+      usernameProperty?: string
+      passwordProperty?: string
+      /**
+       * This option can be used to specify (eager) scopes to be applied when
+       * the user is deserialized from the session.
+       */
+      sessionScope?: OrArrayOf<string>
+    }
 
-export const SessionMixin: <T extends Constructor>(
-  target: T
-) => Constructor<InstanceType<T> & {
-  id: string
-  value: { [key: string]: any }
-}>
+    // TODO: type options
+    login(ctx: KoaContext, options: any): Promise<void>
 
-export const UserMixin: <T extends Constructor>(
-  target: T
-) => Constructor<
-  InstanceType<T> & {
-    id: string
-    value: { [key: string]: any }
+    sessionQuery(
+      trx: Knex.Transaction
+    ): QueryBuilder<InstanceType<typeof UserModel>>
   }
->
+
+export const UserModel: ReturnType<typeof UserMixin<typeof Model>>
 
 /**
  * Apply the action mixin to a controller action, in order to determine which
@@ -1868,25 +1855,16 @@ type ModelFromModelController<$ModelController extends ModelController> =
   InstanceType<Exclude<$ModelController['modelClass'], undefined>>
 
 export type SelectModelProperties<T> = {
-  [$Key in SelectModelKeys<T>]: T[$Key] extends Model
-    ? SelectModelProperties<T[$Key]>
-    : T[$Key]
+  [K in SelectModelKeys<T>]: T[K] extends Model
+    ? SelectModelProperties<T[K]>
+    : T[K]
 }
 
-// https://stackoverflow.com/questions/49927523/disallow-call-with-any/49928360#49928360
-type AnyGate<
-  $CheckType,
-  $TypeWhenNotAny,
-  $TypeWhenAny = $CheckType
-> = 0 extends 1 & $CheckType ? $TypeWhenAny : $TypeWhenNotAny
-
-export type SelectModelKeys<T> = AnyGate<
-  T,
-  Exclude<
-    keyof ConditionalExcept<T, Function>,
-    `$${string}` | 'QueryBuilderType' | 'foreignKeyId'
-  >,
-  string
+export type SelectModelKeys<T> = Exclude<
+  objection.NonFunctionPropertyNames<T>,
+  | 'QueryBuilderType' //
+  | 'foreignKeyId'
+  | `$${string}`
 >
 
 /* ---------------------- Extended from Ajv JSON Schema --------------------- */
@@ -2001,11 +1979,10 @@ interface StringKeywords {
     | 'timestamp'
   >
 }
-declare type UncheckedJSONSchemaType<
-  T,
-  IsPartial extends boolean
-> = // these two unions allow arbitrary unions of types
-(| {
+
+// The first two unions allow arbitrary unions of types
+declare type UncheckedJSONSchemaType<T, IsPartial extends boolean> = (
+  | {
       anyOf: readonly UncheckedJSONSchemaType<T, IsPartial>[]
     }
   | {
@@ -2015,118 +1992,127 @@ declare type UncheckedJSONSchemaType<
       type: readonly (T extends number
         ? JSONType<'number' | 'integer', IsPartial>
         : T extends string
-        ? JSONType<'string', IsPartial>
-        : T extends boolean
-        ? JSONType<'boolean', IsPartial>
-        : never)[]
+          ? JSONType<'string', IsPartial>
+          : T extends boolean
+            ? JSONType<'boolean', IsPartial>
+            : never)[]
     } & UnionToIntersection<
       T extends number
         ? NumberKeywords
         : T extends string
-        ? StringKeywords
-        : T extends boolean
-        ? {}
-        : never
+          ? StringKeywords
+          : T extends boolean
+            ? {}
+            : never
     >)
   | ((T extends number
       ? {
           type: JSONType<'number' | 'integer', IsPartial>
         } & NumberKeywords
       : T extends string
-      ? {
-          type: JSONType<
-            'string' | 'text' | 'date' | 'datetime' | 'timestamp',
-            IsPartial
-          >
-        } & StringKeywords
-      : T extends Date
-      ? {
-          type: JSONType<'date' | 'datetime' | 'timestamp', IsPartial>
-        }
-      : T extends boolean
-      ? {
-          type: JSONType<'boolean', IsPartial>
-        }
-      : T extends readonly [any, ...any[]]
-      ? {
-          type: JSONType<'array', IsPartial>
-          items: {
-            readonly [K in keyof T]-?: UncheckedJSONSchemaType<T[K], false> &
-              Nullable<T[K]>
-          } & {
-            length: T['length']
-          }
-          minItems: T['length']
-        } & (
-          | {
-              maxItems: T['length']
-            }
-          | {
-              additionalItems: false
-            }
-        )
-      : T extends readonly any[]
-      ? {
-          type: JSONType<'array', IsPartial>
-          items: UncheckedJSONSchemaType<T[0], false>
-          contains?: UncheckedPartialSchema<T[0]>
-          minItems?: number
-          maxItems?: number
-          minContains?: number
-          maxContains?: number
-          uniqueItems?: true
-          additionalItems?: never
-        }
-      : T extends Record<string, any>
-      ? {
-          type: JSONType<'object', IsPartial>
-          additionalProperties?:
-            | boolean
-            | UncheckedJSONSchemaType<T[string], false>
-          unevaluatedProperties?:
-            | boolean
-            | UncheckedJSONSchemaType<T[string], false>
-          properties?: IsPartial extends true
-            ? Partial<UncheckedPropertiesSchema<T>>
-            : UncheckedPropertiesSchema<T>
-          patternProperties?: Record<
-            string,
-            UncheckedJSONSchemaType<T[string], false>
-          >
-          propertyNames?: Omit<
-            UncheckedJSONSchemaType<string, false>,
-            'type'
-          > & {
-            type?: 'string'
-          }
-          dependencies?: {
-            [K in keyof T]?: Readonly<(keyof T)[]> | UncheckedPartialSchema<T>
-          }
-          dependentRequired?: {
-            [K in keyof T]?: Readonly<(keyof T)[]>
-          }
-          dependentSchemas?: {
-            [K in keyof T]?: UncheckedPartialSchema<T>
-          }
-          minProperties?: number
-          maxProperties?: number
-        } & (IsPartial extends true
-          ? {
-              required: Readonly<(keyof T)[] | boolean>
-            }
-          : [UncheckedRequiredMembers<T>] extends [never]
+        ? {
+            type: JSONType<
+              'string' | 'text' | 'date' | 'datetime' | 'timestamp',
+              IsPartial
+            >
+          } & StringKeywords
+        : T extends Date
           ? {
-              required?: Readonly<UncheckedRequiredMembers<T>[]> | boolean
+              type: JSONType<'date' | 'datetime' | 'timestamp', IsPartial>
             }
-          : {
-              required: Readonly<UncheckedRequiredMembers<T>[]> | boolean
-            })
-      : T extends null
-      ? {
-          type: JSONType<'null', IsPartial>
-          nullable: true
-        }
-      : never) & {
+          : T extends boolean
+            ? {
+                type: JSONType<'boolean', IsPartial>
+              }
+            : T extends readonly [any, ...any[]]
+              ? {
+                  type: JSONType<'array', IsPartial>
+                  items: {
+                    readonly [K in keyof T]-?: UncheckedJSONSchemaType<
+                      T[K],
+                      false
+                    > &
+                      Nullable<T[K]>
+                  } & {
+                    length: T['length']
+                  }
+                  minItems: T['length']
+                } & (
+                  | {
+                      maxItems: T['length']
+                    }
+                  | {
+                      additionalItems: false
+                    }
+                )
+              : T extends readonly any[]
+                ? {
+                    type: JSONType<'array', IsPartial>
+                    items: UncheckedJSONSchemaType<T[0], false>
+                    contains?: UncheckedPartialSchema<T[0]>
+                    minItems?: number
+                    maxItems?: number
+                    minContains?: number
+                    maxContains?: number
+                    uniqueItems?: true
+                    additionalItems?: never
+                  }
+                : T extends Record<string, any>
+                  ? {
+                      type: JSONType<'object', IsPartial>
+                      additionalProperties?:
+                        | boolean
+                        | UncheckedJSONSchemaType<T[string], false>
+                      unevaluatedProperties?:
+                        | boolean
+                        | UncheckedJSONSchemaType<T[string], false>
+                      properties?: IsPartial extends true
+                        ? Partial<UncheckedPropertiesSchema<T>>
+                        : UncheckedPropertiesSchema<T>
+                      patternProperties?: Record<
+                        string,
+                        UncheckedJSONSchemaType<T[string], false>
+                      >
+                      propertyNames?: Omit<
+                        UncheckedJSONSchemaType<string, false>,
+                        'type'
+                      > & {
+                        type?: 'string'
+                      }
+                      dependencies?: {
+                        [K in keyof T]?:
+                          | Readonly<(keyof T)[]>
+                          | UncheckedPartialSchema<T>
+                      }
+                      dependentRequired?: {
+                        [K in keyof T]?: Readonly<(keyof T)[]>
+                      }
+                      dependentSchemas?: {
+                        [K in keyof T]?: UncheckedPartialSchema<T>
+                      }
+                      minProperties?: number
+                      maxProperties?: number
+                    } & (IsPartial extends true
+                      ? {
+                          required: Readonly<(keyof T)[] | boolean>
+                        }
+                      : [UncheckedRequiredMembers<T>] extends [never]
+                        ? {
+                            required?:
+                              | Readonly<UncheckedRequiredMembers<T>[]>
+                              | boolean
+                          }
+                        : {
+                            required:
+                              | Readonly<UncheckedRequiredMembers<T>[]>
+                              | boolean
+                          })
+                  : T extends null
+                    ? {
+                        type: JSONType<'null', IsPartial>
+                        nullable: true
+                      }
+                    : never) & {
       allOf?: Readonly<UncheckedPartialSchema<T>[]>
       anyOf?: Readonly<UncheckedPartialSchema<T>[]>
       oneOf?: Readonly<UncheckedPartialSchema<T>[]>
@@ -2142,6 +2128,7 @@ declare type UncheckedJSONSchemaType<
   $defs?: Record<string, UncheckedJSONSchemaType<Known, true>>
   definitions?: Record<string, UncheckedJSONSchemaType<Known, true>>
 }
+
 declare type JSONSchemaType<T> = StrictNullChecksWrapper<
   'JSONSchemaType',
   UncheckedJSONSchemaType<T, false>