Pull Request Checklist

• Have you added new tests to prevent regressions?
• If a documentation update is necessary, have you opened a PR to the documentation repository? — not applicable, no behavior/API change
• Did you update the typescript typings accordingly (if applicable)? — not applicable
• Does the description below contain a link to an existing issue (Closes #[issue]) or a description of the issue you are solving?
• Does the name of your PR follow our conventions?

Closes #18233

Description of Changes

The problem we hit

isModelStatic() calls require('../model') on every invocation:

export function isModelStatic<M extends Model>(val: any): val is ModelStatic<M> {
  // TODO: temporary workaround due to cyclic import.
  const { Model: TmpModel } = require('../model');

  return typeof val === 'function' && val.prototype instanceof TmpModel;
}

isModelStatic is on a hot path — it runs (directly, and via isSameInitialModel / extractModelDefinition) once per association while building queries. Although Node caches the loaded module, the require() call itself still funnels through Module._load and re-resolves the request every time.

We ran into this in production: under our Node module-resolution setup, that per-call require('../model') repeatedly walked trySelf → findParentPackageJSON → fs.stat, and on include-heavy queries (many associations) the resolution overhead showed up at the top of our CPU profiles. We were running this fix as a patch-package patch against @sequelize/core@7.0.0-alpha.47 and wanted to upstream it.

Even on a plain Node setup where each resolution is cheaper, the work is pure waste: the resolved Model class never changes once the module graph is initialized.

The fix

Cache the resolved Model class in a module-level variable and reuse it on subsequent calls. The lazy require (the cyclic-import workaround) is preserved for the first call, so module-load ordering is unchanged; only the redundant re-resolution on later calls is removed.

let cachedModelClass: ModelStatic | undefined;

export function isModelStatic<M extends Model>(val: any): val is ModelStatic<M> {
  // TODO: temporary workaround due to cyclic import. ...
  cachedModelClass ??= require('../model').Model as ModelStatic;

  return typeof val === 'function' && val.prototype instanceof cachedModelClass;
}

Tests

Added a unit test that spies on Module._load and asserts the Model module is not re-resolved across 50 isModelStatic calls after warm-up.

I verified locally that the test passes with the fix and fails without it (the uncached version resolves the module once per call — 50 times). Behavior is unchanged and remains covered by the existing isModelStatic / isSameInitialModel tests; yarn eslint and yarn lerna run test-typings --scope=@sequelize/core both pass.

List of Breaking Changes

None. This is an internal, behavior-preserving performance optimization.

Summary by CodeRabbit

• Refactor

  • Improved performance by caching a frequently accessed class to avoid repeated module reloads.

• Tests

  • Added unit test to verify the caching behavior and prevent repeated module resolution during repeated calls.