@tanstack/query-core 5.67.1: QueriesObserver

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify QueriesObserver in pkg:npm/%40tanstack/query-core@5.67.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/%40tanstack/query-core@5.67.1
Demonstrate these symbols/APIs:
  - QueriesObserver
Constraints:
  - executionContext: node
Required runtime conditions:
  - ecosystem: npm
  - language: javascript
  - moduleSystem: cjs
  - packageManager: npm@10.9.8
  - runtime: node@22.23.2

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:0d2a8b081558931c9d7590ddf9d1460067b16ede7cb6393fc650b773ad707e31","constraints":{"executionContext":"node"},"contract":["assert QueriesObserver constructs an instance with observer methods","assert QueriesObserver getCurrentResult returns query results for all tracked queries","assert QueriesObserver getOptimisticResult returns combined result tuple for queries","assert QueriesObserver subscribe notifies listeners of query state changes","assert QueriesObserver unsubscribe stops listener notifications on subsequent updates","assert QueriesObserver setQueries updates tracked queries dynamically","assert QueriesObserver destroy clears listeners and prevents future notifications"],"goal":"verify QueriesObserver in pkg:npm/%40tanstack/query-core@5.67.1","kind":"HOW","packages":["pkg:npm/%40tanstack/query-core@5.67.1"],"schemaVersion":1,"symbols":["QueriesObserver"]},"contractCommand":["node","test/contract.js"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"cjs","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/%40tanstack/query-core@5.67.1"],"schemaVersion":1,"subject":"pkg:npm/%40tanstack/query-core@5.67.1","symbols":["QueriesObserver"],"verifierAdapter":"node-typescript@1"}

const { QueriesObserver, QueryClient } = require('@tanstack/query-core');

/**
 * Creates a new QueriesObserver instance for the given QueryClient and queries.
 *
 * @param {QueryClient} client
 * @param {Array<object>} queries
 * @returns {QueriesObserver}
 */
function createQueriesObserver(client, queries) {
  return new QueriesObserver(client, queries);
}

/**
 * Subscribes a listener to QueriesObserver state transitions.
 *
 * @param {QueriesObserver} observer
 * @param {Function} listener
 * @returns {Function} Unsubscribe function
 */
function subscribeQueries(observer, listener) {
  return observer.subscribe(listener);
}

/**
 * Sets queries dynamically on a QueriesObserver.
 *
 * @param {QueriesObserver} observer
 * @param {Array<object>} queries
 */
function setObserverQueries(observer, queries) {
  observer.setQueries(queries);
}

module.exports = {
  QueriesObserver,
  QueryClient,
  createQueriesObserver,
  subscribeQueries,
  setObserverQueries,
};

{
  "name": "sample-query-core-queries-observer",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-query-core-queries-observer",
      "version": "1.0.0",
      "dependencies": {
        "@tanstack/query-core": "5.67.1"
      }
    },
    "node_modules/@tanstack/query-core": {
      "version": "5.67.1",
      "resolved": "https://registry.npmjs.org/@tanstack/query-core/-/query-core-5.67.1.tgz",
      "integrity": "sha512-AkFmuukVejyqVIjEQoFhLb3q+xHl7JG8G9cANWTMe3s8iKzD9j1VBSYXgCjy6vm6xM8cUCR9zP2yqWxY9pTWOA==",
      "license": "MIT",
      "funding": {
        "type": "github",
        "url": "https://github.com/sponsors/tannerlinsley"
      }
    }
  }
}

{
  "name": "sample-query-core-queries-observer",
  "version": "1.0.0",
  "private": true,
  "main": "index.js",
  "dependencies": {
    "@tanstack/query-core": "5.67.1"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify QueriesObserver in pkg:npm/%40tanstack/query-core@5.67.1",
  "kind": "HOW",
  "packages": [
    "pkg:npm/%40tanstack/query-core@5.67.1"
  ],
  "symbols": [
    "QueriesObserver"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}

const assert = require('node:assert/strict');
const {
  QueriesObserver,
  QueryClient,
  createQueriesObserver,
  subscribeQueries,
  setObserverQueries,
} = require('../index.js');

const client = new QueryClient();

// 1. assert QueriesObserver constructs an instance with observer methods
{
  const observer = createQueriesObserver(client, [
    { queryKey: ['probe', 1], queryFn: () => 'data1' },
    { queryKey: ['probe', 2], queryFn: () => 'data2' },
  ]);

  assert.ok(observer instanceof QueriesObserver);
  assert.strictEqual(typeof observer.subscribe, 'function');
  assert.strictEqual(typeof observer.getCurrentResult, 'function');
  assert.strictEqual(typeof observer.getOptimisticResult, 'function');
  assert.strictEqual(typeof observer.setQueries, 'function');
  assert.strictEqual(typeof observer.destroy, 'function');
  assert.strictEqual(typeof observer.getObservers, 'function');
}

// 2. assert QueriesObserver getCurrentResult returns query results for all tracked queries
{
  client.setQueryData(['items', 1], { id: 1, name: 'First' });
  client.setQueryData(['items', 2], { id: 2, name: 'Second' });

  const observer = new QueriesObserver(client, [
    { queryKey: ['items', 1], queryFn: () => ({ id: 1, name: 'First' }) },
    { queryKey: ['items', 2], queryFn: () => ({ id: 2, name: 'Second' }) },
  ]);

  const results = observer.getCurrentResult();
  assert.strictEqual(results.length, 2);
  assert.strictEqual(results[0].status, 'success');
  assert.deepStrictEqual(results[0].data, { id: 1, name: 'First' });
  assert.strictEqual(results[1].status, 'success');
  assert.deepStrictEqual(results[1].data, { id: 2, name: 'Second' });
}

// 3. assert QueriesObserver getOptimisticResult returns combined result tuple for queries
{
  client.setQueryData(['opt', 1], 'alpha');
  client.setQueryData(['opt', 2], 'beta');

  const queries = [
    { queryKey: ['opt', 1], queryFn: () => 'alpha' },
    { queryKey: ['opt', 2], queryFn: () => 'beta' },
  ];
  const observer = new QueriesObserver(client, queries);

  const [optResults] = observer.getOptimisticResult(queries);
  assert.strictEqual(optResults.length, 2);
  assert.strictEqual(optResults[0].data, 'alpha');
  assert.strictEqual(optResults[1].data, 'beta');
}

// 4. assert QueriesObserver subscribe notifies listeners of query state changes
{
  client.setQueryData(['sub', 1], 'initial');
  const observer = new QueriesObserver(client, [
    { queryKey: ['sub', 1], queryFn: () => 'initial' },
  ]);

  const updates = [];
  const unsubscribe = subscribeQueries(observer, (results) => {
    updates.push(results[0].data);
  });

  client.setQueryData(['sub', 1], 'updated');
  unsubscribe();

  assert.ok(updates.includes('updated'));
}

// 5. assert QueriesObserver unsubscribe stops listener notifications on subsequent updates
{
  client.setQueryData(['unsub', 1], 'v1');
  const observer = new QueriesObserver(client, [
    { queryKey: ['unsub', 1], queryFn: () => 'v1' },
  ]);

  let callCount = 0;
  const unsubscribe = observer.subscribe(() => {
    callCount++;
  });

  const countAtUnsub = callCount;
  unsubscribe();

  client.setQueryData(['unsub', 1], 'v2');
  assert.strictEqual(callCount, countAtUnsub);
}

// 6. assert QueriesObserver setQueries updates tracked queries dynamically
{
  client.setQueryData(['dyn', 10], 'ten');
  client.setQueryData(['dyn', 20], 'twenty');

  const observer = new QueriesObserver(client, [
    { queryKey: ['dyn', 10], queryFn: () => 'ten' },
  ]);

  assert.strictEqual(observer.getObservers().length, 1);

  setObserverQueries(observer, [
    { queryKey: ['dyn', 10], queryFn: () => 'ten' },
    { queryKey: ['dyn', 20], queryFn: () => 'twenty' },
  ]);

  assert.strictEqual(observer.getObservers().length, 2);
  const results = observer.getCurrentResult();
  assert.strictEqual(results.length, 2);
  assert.strictEqual(results[0].data, 'ten');
  assert.strictEqual(results[1].data, 'twenty');
}

// 7. assert QueriesObserver destroy clears listeners and prevents future notifications
{
  client.setQueryData(['dest', 1], 'active');
  const observer = new QueriesObserver(client, [
    { queryKey: ['dest', 1], queryFn: () => 'active' },
  ]);

  let notifyCalled = false;
  observer.subscribe(() => {
    notifyCalled = true;
  });

  notifyCalled = false;
  observer.destroy();

  client.setQueryData(['dest', 1], 'inactive');
  assert.strictEqual(notifyCalled, false);
}

console.log('All QueriesObserver contract assertions passed.');