cube-js/cube · error · Error

Cannot check property existence on

Error message

Cannot check property existence on ${instanceName}. The '${name}' has been cleaned up and is no longer available.

What it means

The `has` trap of the disposed proxy fires when the `in` operator (or `Reflect.has`) is used against an already-disposed Cube internal. Cube swaps disposed instances for this proxy so any dangling reference fails loudly. Seeing it means code is probing an object that was cleaned up.

Solutions

Do not run property-existence checks on instances after their owner has been disposed.
Perform the `in` check before teardown, or re-fetch a live instance reference.
Remove the stale reference when the owner is disposed (set it to null and check before use).

Example fix

// before
const orchestrator = server.orchestrator;
server.dispose();
if ('compileQuery' in orchestrator) { orchestrator.compileQuery(); }

// after
let orchestrator = server.orchestrator;
server.dispose();
orchestrator = null;
if (orchestrator && 'compileQuery' in orchestrator) { orchestrator.compileQuery(); }

Defensive patterns

Strategy: try-catch

Validate before calling

if (objRef == null) {
  throw new Error('Reference cleared before `in` check.');
}

Type guard

function isUsable<T extends object>(ref: T | null | undefined): ref is T {
  if (ref == null) return false;
  try {
    Object.keys(ref); // throws on disposed proxy via ownKeys
    return true;
  } catch {
    return false;
  }
}

Try / catch

let exists = false;
try {
  exists = 'prop' in possiblyDisposed;
} catch (e) {
  if (e.message.includes('has been cleaned up')) {
    exists = false; // treat disposed objects as lacking all props
  } else {
    throw e;
  }
}

Prevention

Do feature detection before teardown, not after.
Clear cached references when the owning component is disposed.
Avoid duck-typing on long-lived Cube internals; use explicit flags instead.
Guard stale references with a null check before any property probe.

When it happens

Trigger: Executing `'methodName' in someDisposedInstance` or a feature-check like `if ('foo' in obj)` where obj was replaced by the disposed proxy after its owner's cleanup ran.

Common situations: Duck-typing/feature detection on cached Cube internals after dispose; library code defensively checking properties on an object that was torn down; hot-reload leaving stale module-level references.

Related errors

AI-assisted analysis of cube-js/cube@7d981676b3 (2026-09-02). Data as JSON: /api/errors/ad92c56cc3ba305c. Report an issue: GitHub.

Appendix: source

Thrown at packages/cubejs-backend-shared/src/disposedProxy.ts:26

      throw new Error(
        `Cannot access property '${String(prop)}' on ${instanceName}. ` +
        `The '${name}' has been cleaned up and is no longer available.`
      );
    },
    set(_target: object, prop: string | symbol): never {
      throw new Error(
        `Cannot set property '${String(prop)}' on ${instanceName}. ` +
        `The '${name}' has been cleaned up and is no longer available.`
      );
    },
    apply(): never {
      throw new Error(
        `Cannot call method on ${instanceName}. ` +
        `The '${name}' has been cleaned up and is no longer available.`
      );
    },
    has(_target: object, _prop: string | symbol): never {
      throw new Error(
        `Cannot check property existence on ${instanceName}. ` +
        `The '${name}' has been cleaned up and is no longer available.`
      );
    },
    ownKeys(): never {
      throw new Error(
        `Cannot enumerate properties on ${instanceName}. ` +
        `The '${name}' has been cleaned up and is no longer available.`
      );
    },
    getPrototypeOf(): never {
      throw new Error(
        `Cannot get prototype of ${instanceName}. ` +
        `The '${name}' has been cleaned up and is no longer available.`
      );
    }
  });
}

View on GitHub (pinned to 7d981676b3)