@starci/jest-preset 2.3.6 → 2.4.0

package/mock.cjs

@@ -1,53 +0,0 @@
-"use strict"
-
-/**
- * `mock<T>()` -- a typed test double that replaces the `{ ... } as unknown as T` cast.
- *
- * Every property read yields one stable `jest.fn()` (created on first read), so `mock<Repo>().find` is
- * already a mock function, `expect(m.find).toHaveBeenCalledWith(...)` works, and `m.find.mockResolvedValue(x)`
- * type-checks against `Repo["find"]`. Values passed in `overrides` win over the generated functions and may be
- * partial: the return type is still `T`.
- *
- * `createMock` takes the function factory as an argument (called with the property name) so the helper has no hard
- * dependency on a global `jest`; `mock` binds it to `jest.fn`.
- */
-
-// Probed by promise resolution, jest matchers and serializers: they must read as absent, not as a mock function.
-const ABSENT = new Set(["then", "asymmetricMatch", "$$typeof", "nodeType", "tagName", "toJSON"])
-
-function createMock(makeFn) {
-  return function mock(overrides) {
-    const own = new Map()
-    const store = overrides ? { ...overrides } : {}
-    return new Proxy(store, {
-      get(target, property, receiver) {
-        if (Object.hasOwn(target, property)) return Reflect.get(target, property, receiver)
-        if (typeof property === "symbol" || property in Object.prototype) return Reflect.get(target, property, receiver)
-        if (ABSENT.has(property)) return undefined
-        if (!own.has(property)) own.set(property, makeFn(property))
-        return own.get(property)
-      },
-      set(target, property, value) {
-        own.delete(property)
-        target[property] = value
-        return true
-      },
-      has(target, property) {
-        return Object.hasOwn(target, property) || own.has(property)
-      },
-    })
-  }
-}
-
-// jest-runtime hands every module it loads, this one included, a module-scoped `jest` object; it is not a property
-// of globalThis, so it is read as a free identifier. @jest/globals is the fallback for a runner that does not.
-function jestFn(implementation) {
-  if (typeof jest !== "undefined" && typeof jest.fn === "function") return jest.fn(implementation)
-  try {
-    return require("@jest/globals").jest.fn(implementation)
-  } catch {
-    throw new Error("@starci/jest-preset mock<T>() needs the jest runtime; call it from a jest test")
-  }
-}
-
-module.exports = { mock: createMock(() => jestFn()), createMock, jestFn }

package/mock.d.ts

@@ -1,12 +0,0 @@
-/// <reference types="jest" />
-
-/** Function members become jest mocks typed against the real signature; everything else stays as declared. */
-export type MockOf<T> = T & {
-  [K in keyof T]: T[K] extends (...args: infer A) => infer R ? jest.Mock<R, A> & T[K] : T[K]
-}
-
-/** A typed test double for `T`. `overrides` may be partial; the result is usable wherever a `T` is required. */
-export declare function mock<T extends object>(overrides?: Partial<T>): MockOf<T>
-
-/** The factory behind `mock`, for callers that bring their own function factory (used by the package spec). */
-export declare function createMock(makeFn: () => unknown): <T extends object>(overrides?: Partial<T>) => MockOf<T>

package/queue.cjs

@@ -1,51 +0,0 @@
-"use strict"
-
-/**
- * `recordingQueueOutbox()` -- a `QueueOutbox` double that records what a typed queue producer writes, so a spec asserts on `outbox.jobs`.
- *
- * `write(tx, queue, payload)` records the job with the manager it was written through. `jobs` is every job in order, `jobsOf(queue)`
- * the jobs of one queue, and `entries` adds `inTransaction`: whether `tx` was the view a `fakeTransaction` body received, so a spec proves
- * a job is enqueued in the transaction of the change that needs it. `failNext('write', error)` makes the next write reject once.
- */
-const { isTransactionManager } = require("./entity-manager.cjs")
-
-function recordingQueueOutbox() {
-  const written = []
-  const failures = new Map()
-  return {
-    async write(tx, queue, payload) {
-      if (failures.has("write")) {
-        const error = failures.get("write")
-        failures.delete("write")
-        throw error
-      }
-      written.push({ queue, payload, tx, inTransaction: isTransactionManager(tx) })
-    },
-    /** Every job written, in order: `{ queue, payload }`. */
-    get jobs() {
-      return written.map(({ queue, payload }) => ({ queue, payload }))
-    },
-    /** Every write with its manager and `inTransaction`. */
-    get entries() {
-      return [...written]
-    },
-    /** The jobs of one queue. */
-    jobsOf(queue) {
-      return this.jobs.filter((job) => job.queue === queue)
-    },
-    /** True when something was written and every write went through a transaction manager. */
-    get allInTransaction() {
-      return written.length > 0 && written.every((entry) => entry.inTransaction)
-    },
-    /** Makes the next write reject with `error`, once. */
-    failNext(operation, error) {
-      failures.set(operation, error)
-    },
-    clear() {
-      written.length = 0
-      failures.clear()
-    },
-  }
-}
-
-module.exports = { recordingQueueOutbox }

package/queue.d.ts

@@ -1,26 +0,0 @@
-/** One recorded job write. */
-export interface QueueWrite {
-  readonly queue: string
-  readonly payload: object
-  readonly tx: unknown
-  /** Whether `tx` was the view a `fakeTransaction` body received. */
-  readonly inTransaction: boolean
-}
-
-/** A `QueueOutbox` double that records the jobs a typed producer writes. */
-export interface RecordingQueueOutbox {
-  write(tx: unknown, queue: string, payload: object): Promise<void>
-  /** Every job written, in order. */
-  readonly jobs: ReadonlyArray<{ readonly queue: string; readonly payload: object }>
-  /** Every write with its manager. */
-  readonly entries: ReadonlyArray<QueueWrite>
-  jobsOf(queue: string): ReadonlyArray<{ readonly queue: string; readonly payload: object }>
-  /** True when something was written and every write went through a `fakeTransaction` manager. */
-  readonly allInTransaction: boolean
-  /** Makes the next write reject with `error`, once. */
-  failNext(operation: "write", error: Error): void
-  clear(): void
-}
-
-/** The queue outbox double. */
-export declare function recordingQueueOutbox(): RecordingQueueOutbox

package/sonar-exclusions.cjs

@@ -1,8 +0,0 @@
-"use strict"
-
-/**
- * Sonar `sonar.exclusions`: specs, e2e specs, dist and coverage output are not analysed at all. A plain list with no require, so
- * @starci/hfs ships this file byte for byte (packages/hfs/runtime, scripts/hfs/sync-runtime.mjs) and `starci app scaffold` renders
- * the same exclusions before any app dependency is installed.
- */
-module.exports = Object.freeze(["**/*.spec.ts", "**/*.e2e-spec.ts", "**/dist/**", "**/coverage/**"])

package/unit-metadata.cjs

@@ -1,63 +0,0 @@
-"use strict"
-
-const METADATA_SOURCE = require.resolve("./unit-metadata.generated.cjs")
-const METADATA_TEXT = require("node:fs").readFileSync(METADATA_SOURCE, "utf8")
-
-/** Only synthetic conditional guards inside compiler-emitted parameter metadata map to the generated-metadata anchor: a zero-width position at its end, which no line covers, so they are measured nowhere and source metadata calls stay measured. */
-function factory(compiler) {
-  const ts = compiler.configSet.compilerModule
-  const source = ts.createSourceMapSource(METADATA_SOURCE, METADATA_TEXT)
-  return (context) => {
-    const visit = (node) => {
-      if (isGeneratedMetadata(ts, node)) {
-        const guard = (child) => {
-          if (isGeneratedGuard(ts, child)) {
-            ts.setSourceMapRange(child, { pos: METADATA_TEXT.length, end: METADATA_TEXT.length, source })
-            ts.setEmitFlags(child, ts.getEmitFlags(child) | ts.EmitFlags.NoNestedSourceMaps)
-            return child
-          }
-          return ts.visitEachChild(child, guard, context)
-        }
-        return ts.visitEachChild(node, guard, context)
-      }
-      return ts.visitEachChild(node, visit, context)
-    }
-    return (file) => ts.visitNode(file, visit)
-  }
-}
-
-/** Only TypeScript's synthetic __metadata("design:paramtypes", ...) call is eligible; source calls remain measured. */
-function isGeneratedMetadata(ts, node) {
-  return node.pos < 0 && ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "__metadata" && node.arguments.length === 2 && ts.isStringLiteral(node.arguments[0]) && node.arguments[0].text === "design:paramtypes"
-}
-
-/** A metadata exclusion requires TypeScript's synthetic `typeof value === "function" ? value : Object` guard shape. */
-function isGeneratedGuard(ts, node) {
-  if (node.pos >= 0 || !ts.isConditionalExpression(node)) return false
-  const condition = node.condition
-  return ts.isBinaryExpression(condition) && condition.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken && ts.isTypeOfExpression(condition.left) && ts.isStringLiteral(condition.right) && condition.right.text === "function" && ts.isIdentifier(node.whenFalse) && node.whenFalse.text === "Object"
-}
-
-/** ts-jest normalizes map sources to the input file; restore the generated metadata anchor before Jest reads the map. */
-function restoreMetadataSource(result) {
-  const prefix = "sourceMappingURL=data:application/json;charset=utf-8;base64,"
-  const offset = result.code.lastIndexOf(prefix)
-  if (offset < 0) return result
-  const start = offset + prefix.length
-  const map = JSON.parse(Buffer.from(result.code.slice(start), "base64").toString("utf8"))
-  if (map.sourcesContent?.length !== 2 || map.sourcesContent[1] !== METADATA_TEXT) return result
-  map.sources = [map.sources[0], METADATA_SOURCE]
-  return { ...result, code: result.code.slice(0, start) + Buffer.from(JSON.stringify(map)).toString("base64") }
-}
-
-/** Unit transforms delegate compilation and caching to ts-jest; the after-transformer changes metadata mappings only. */
-function createTransformer(options) {
-  const delegate = require("ts-jest").default.createTransformer(options)
-  return {
-    getCacheKey: (...args) => delegate.getCacheKey(...args) + ":starci-unit-metadata-6",
-    process: (...args) => restoreMetadataSource(delegate.process(...args)),
-    processAsync: async (...args) => restoreMetadataSource(await delegate.processAsync(...args)),
-  }
-}
-
-module.exports = { name: "starci-unit-metadata", version: 6, factory, createTransformer }

package/world-runner.cjs

@@ -1,142 +0,0 @@
-"use strict"
-
-/**
- * The runner of the integration, e2e and contract projects: every spec file runs in a process of its own, bound to one data
- * slot of the test world.
- *
- * Why a process per file: jest runs a file in a fresh vm context, but a context still reaches the globals of the process that
- * hosts it, and jest-environment-node exposes every global the host process had when the environment loaded. The test world's
- * globalSetup runs in jest's main process and loads application code there (the migrate step and its modules), so a framework
- * that keeps its registry on a process global (`@nestjs/graphql` keeps `GqlTypeMetadataStorage` on `global`) leaks it into
- * every file jest runs in that process; and a worker that runs several files carries whatever the first one left on its own
- * global. A process per file isolates every framework at once.
- *
- * Why slots: the test world resets a slot's data (its databases, realm users, Redis DB, buckets and fakes) when a file boots,
- * so two files must never share a slot at the same time. The globalSetup of `@starci/test-world` provisions N slots, each a
- * complete, independent set of data namespaces, and publishes them in its state file (`STARCI_TEST_WORLD_STATE`, protocol
- * {@link WORLD_STATE_VERSION}). The runner runs up to `min(--maxWorkers, N)` files at once and gives each a free slot: the
- * file's process is forked with `STARCI_TEST_WORLD_SLOT=<k>`; the slot goes back to the pool when the file ends.
- *
- * How: the stock jest-runner, driven one file at a time per slot with a single-worker farm (`maxWorkers: 1` per file), which
- * forks a fresh child, runs the file there and ends the child. jest-worker forks in the farm's constructor, which jest-runner
- * calls before its first `await`, so the slot variable is set on `process.env` only for that synchronous span. Never in band,
- * even when jest would choose it (`--runInBand`): the main process holds the globalSetup's state.
- *
- * The pair is exact: this runner reads protocol {@link WORLD_STATE_VERSION} only. Any other state file is the wrong
- * `@starci/test-world` beside this preset, a typed failure naming both versions (re-pin both per canon-pins), never a fallback.
- */
-
-const { createRequire } = require("node:module")
-const fs = require("node:fs")
-const path = require("node:path")
-
-/** The state-file protocol of `@starci/test-world` this runner speaks (test-world 1.1.x). */
-const WORLD_STATE_VERSION = 2
-/** The variable that carries the path of the world's state file (set by its globalSetup in this process). */
-const STATE_FILE_ENV = "STARCI_TEST_WORLD_STATE"
-/** The variable that tells a file's process which slot it owns (1-based). */
-const SLOT_ENV = "STARCI_TEST_WORLD_SLOT"
-/** The failure code of a state file this runner cannot drive. */
-const WORLD_PAIR_MISMATCH = "JEST_PRESET_WORLD_PAIR_MISMATCH"
-
-const PRESET = (() => {
-  const own = JSON.parse(fs.readFileSync(path.join(__dirname, "package.json"), "utf8"))
-  return `${own.name}@${own.version}`
-})()
-
-/** A typed failure of the runner: `code` names it, the message says what to do. */
-function runnerError(code, detail) {
-  const error = new Error(`${code}: ${detail}`)
-  error.code = code
-  return error
-}
-
-/** The slot count the world published; a missing or foreign state file is a pair mismatch. */
-function worldSlots(env = process.env) {
-  const file = env[STATE_FILE_ENV]
-  const fix = `pin @starci/test-world and @starci/jest-preset together as knowledge/hfs/canon-pins.yaml pairs them (${PRESET} speaks state protocol ${WORLD_STATE_VERSION}, @starci/test-world 1.1.x)`
-  if (file === undefined || file === "") {
-    throw runnerError(WORLD_PAIR_MISMATCH, `${STATE_FILE_ENV} is not set: the world's globalSetup published no state file for ${PRESET}; ${fix}`)
-  }
-  let state
-  try {
-    state = JSON.parse(fs.readFileSync(file, "utf8"))
-  } catch (cause) {
-    throw runnerError(WORLD_PAIR_MISMATCH, `the world state file ${file} cannot be read (${cause instanceof Error ? cause.message : String(cause)}); ${fix}`)
-  }
-  const library = typeof state?.library === "string" ? state.library : "@starci/test-world before 1.1.0"
-  if (state?.version !== WORLD_STATE_VERSION || !Array.isArray(state.slots) || state.slots.length < 1) {
-    throw runnerError(WORLD_PAIR_MISMATCH, `${library} wrote state protocol ${String(state?.version)}, ${PRESET} needs ${WORLD_STATE_VERSION}; ${fix}`)
-  }
-  return state.slots.length
-}
-
-/**
- * The stock jest-runner of the jest that loads this preset: resolved through jest's own dependency chain
- * (jest -> @jest/core -> jest-runner) from the repository root, so the runner always matches the running jest.
- */
-function stockRunner(root = process.cwd()) {
-  const fromRoot = createRequire(path.join(root, "package.json"))
-  const fromJest = createRequire(fromRoot.resolve("jest/package.json"))
-  const fromCore = createRequire(fromJest.resolve("@jest/core"))
-  const loaded = fromCore("jest-runner")
-  return loaded.default ?? loaded
-}
-
-const StockRunner = stockRunner()
-
-class WorldRunner extends StockRunner {
-  #listeners = []
-
-  /** Jest subscribes before the run; the subscriptions are handed to the per-file runner of each file. */
-  on(eventName, listener) {
-    const entry = { eventName, listener }
-    this.#listeners.push(entry)
-    return () => {
-      this.#listeners = this.#listeners.filter((candidate) => candidate !== entry)
-    }
-  }
-
-  /** Runs the files up to `min(--maxWorkers, slots)` at once, each in a fresh process bound to a free slot; never in band. */
-  async runTests(tests, watcher) {
-    const slots = worldSlots()
-    const width = Math.max(1, Math.min(this._globalConfig.maxWorkers ?? 1, slots))
-    const queue = [...tests]
-    // one lane per slot: a lane owns its slot for the whole run and takes the next file when its current one ends
-    const lane = async (slot) => {
-      for (let test = queue.shift(); test !== undefined; test = queue.shift()) {
-        if (watcher.isInterrupted()) return
-        await this.#runOne(test, watcher, slot)
-      }
-    }
-    await Promise.all(Array.from({ length: Math.min(width, tests.length) }, (_, index) => lane(index + 1)))
-  }
-
-  /** One file in a fresh single-worker farm whose child is forked with the slot in its environment. */
-  async #runOne(test, watcher, slot) {
-    const runner = new StockRunner({ ...this._globalConfig, maxWorkers: 1 }, this._context)
-    const unsubscribe = this.#listeners.map(({ eventName, listener }) => runner.on(eventName, listener))
-    const before = process.env[SLOT_ENV]
-    let running
-    process.env[SLOT_ENV] = String(slot)
-    try {
-      // the farm (and its child) is created synchronously inside this call, before jest-runner's first await
-      running = runner.runTests([test], watcher, { serial: false })
-    } finally {
-      if (before === undefined) delete process.env[SLOT_ENV]
-      else process.env[SLOT_ENV] = before
-    }
-    try {
-      await running
-    } finally {
-      for (const stop of unsubscribe) stop()
-    }
-  }
-}
-
-WorldRunner.WORLD_STATE_VERSION = WORLD_STATE_VERSION
-WorldRunner.SLOT_ENV = SLOT_ENV
-WorldRunner.WORLD_PAIR_MISMATCH = WORLD_PAIR_MISMATCH
-WorldRunner.worldSlots = worldSlots
-
-module.exports = WorldRunner