joist-core 2.3.0 → 2.4.0-next.10

package/build/dataloaders/findDataLoader.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"findDataLoader.cjs","names":["getMetadata","parseFindQuery","isQueryProvablyEmpty","hintKey","getEmInternalApi","buildHintTree","buildUnnestCte","getTables","fastWhereFilterHash","kqDot","parseAlias","opToFn","fail","equal","equalArrays"],"sources":["../../src/dataloaders/findDataLoader.ts"],"sourcesContent":["import { fastWhereFilterHash } from \"src/dataloaders/fastWhereFilterHash.ts\";\nimport type { OpColumn } from \"src/drivers/EntityWriter.ts\";\nimport type { Entity } from \"src/Entity.ts\";\nimport { type EntityManager, type MaybeAbstractEntityConstructor, getEmInternalApi } from \"src/EntityManager.ts\";\nimport { type EntityMetadata, getMetadata } from \"src/EntityMetadata.ts\";\nimport { equal, equalArrays } from \"src/fields.ts\";\nimport { buildHintTree } from \"src/loading/HintTree.ts\";\nimport type { LoadHint } from \"src/loading/loadHints.ts\";\nimport { hintKey } from \"src/normalizeHints.ts\";\nimport type { FilterAndSettings } from \"src/queries/find/EntityFilter.ts\";\nimport { opToFn } from \"src/queries/find/EntityGraphQLFilter.ts\";\nimport {\n  type ParsedCteClause,\n  type ParsedFindQuery,\n  type ParsedGroupBy,\n  type ParsedSelect,\n  getTables,\n  parseAlias,\n  parseFindQuery,\n} from \"src/queries/find/QueryParser.ts\";\nimport { isQueryProvablyEmpty, visitConditions } from \"src/queries/find/QueryVisitor.ts\";\nimport type { ColumnCondition, ParsedValueFilter, RawCondition } from \"src/queries/parsedConditions.ts\";\nimport { kqDot } from \"src/queries/sql/keywords.ts\";\nimport { buildUnnestCte } from \"src/queries/unnest.ts\";\nimport { assertNever, fail } from \"src/utils.ts\";\n\nexport const findOperation = \"find\";\n\ninterface PreparedFindEntry<T extends Entity> {\n  filter: FilterAndSettings<T>;\n  query: ParsedFindQuery;\n  bindings: any[];\n  findSettings: any;\n  checkLimit: boolean | undefined;\n}\n\nexport function findDataLoader<T extends Entity>(\n  em: EntityManager,\n  type: MaybeAbstractEntityConstructor<T>,\n  filter: FilterAndSettings<T>,\n  hint: LoadHint<T> | undefined,\n): Promise<T[]> {\n  const { where, ...opts } = filter;\n  if (\"limit\" in opts || \"offset\" in opts) {\n    throw new Error(\"Cannot use limit/offset with findDataLoader\");\n  }\n\n  const meta = getMetadata(type);\n  const query = parseFindQuery(meta, where, opts);\n  const { checkLimit, findSettings } = em[\"prepareFind\"](meta, findOperation, query, {\n    ...opts,\n    limit: em.entityLimit,\n  });\n  if (isQueryProvablyEmpty(query)) return Promise.resolve([]);\n\n  const bindings: any[] = [];\n  collectValues(bindings, query);\n  const prepared = { filter, query, bindings, findSettings, checkLimit } satisfies PreparedFindEntry<T>;\n  const batchKey = getBatchKeyFromGenericStructure(meta, query);\n\n  return em\n    .getLoader<PreparedFindEntry<T>, T[]>(\n      findOperation,\n      // It's unlikely we'll have simultaneous em.finds with the same WHERE clause structure\n      // but lots of different load hints, and it'd be complicated to implement the preloading\n      // in a way that doesn't naively over-fetch data (which our loadDataLoader does prevent,\n      // but it's simpler b/c it's given exact ids to load), so for now just include the load\n      // hint in the batch key.\n      `${batchKey}-${hintKey(hint)}`,\n      async (entries) => {\n        // We're guaranteed that these queries all have the same structure\n\n        // Don't bother with the CTE if there's only 1 query (or each query has exactly the same filter values)\n        if (entries.length === 1) {\n          const { query, findSettings, checkLimit } = entries[0];\n          // Maybe add preload joins\n          const { preloader } = getEmInternalApi(em);\n          const preloadHydrator = preloader && hint && preloader.addPreloading(meta, buildHintTree(hint), query);\n          const rowData = await em[\"executePreparedFindRowData\"](meta, findOperation, query, findSettings, checkLimit);\n          const entities = em[\"hydrateAndFinalize\"](type, rowData, {\n            sidecars: (entities) => preloadHydrator?.(rowData, entities),\n          });\n          return [filterDeletedEntities(em, entities)];\n        }\n\n        // WITH _find (tag, arg1, arg2) AS (\n        //   SELECT unnest($0::int[]), unnest($0::varchar[]), unnest($0::varchar[])\n        // )\n        // SELECT a.*, array_agg(_find.tag) AS _tags\n        // FROM authors a\n        // CROSS JOIN _find AS _find\n        // WHERE a.first_name = _find.arg0 OR a.last_name = _find.arg1\n        // GROUP BY a.id\n\n        // Build the list of 'arg1', 'arg2', ... strings\n        const { query, findSettings, checkLimit } = entries[0];\n        const { preloader } = getEmInternalApi(em);\n        const preloadJoins = preloader && hint && preloader.getPreloadJoins(meta, buildHintTree(hint), query);\n\n        const args = collectAndReplaceArgs(query, entries);\n        const argsColumns: OpColumn[] = [{ columnName: \"tag\", dbType: \"int\" }, ...args.map((a) => a.column)];\n        const columnValues = createColumnValuesFromPrepared(args, entries);\n        const query2: ParsedFindQuery = {\n          ...query,\n          selects: [\"array_agg(_find.tag) as _tags\", ...query.selects],\n          tables: [{ join: \"cross\", table: \"_find\", alias: \"_find\" }, ...query.tables],\n          ctes: [buildUnnestCte(\"_find\", argsColumns, columnValues), ...(query.ctes ?? [])],\n        };\n        if (preloadJoins) {\n          query2.selects.push(\n            ...preloadJoins.flatMap((j) =>\n              // Because we 'group by primary.id' to collapse the \"a1 matched multiple finds\" into\n              // a single row, we also need to pick just the first value of each preload column\n              j.selects.map((s) => `(array_agg(${s.value}))[1] AS ${s.as}`),\n            ),\n          );\n          query2.tables.push(...preloadJoins.map((j) => j.join));\n        }\n\n        // Because we want to use `array_agg(tag)`, add `GROUP BY`s to the values we're selecting\n        query2.groupBys = buildGroupBys(query2.selects);\n\n        // Also because of our `array_agg` group by, add any order bys to the group by\n        const [primary] = getTables(query2);\n        for (const { alias, column } of query2.orderBys) {\n          if (alias !== primary.alias) {\n            query2.groupBys.push({ alias, column });\n          }\n        }\n\n        const rowData = await em[\"executePreparedFindRowData\"](meta, findOperation, query2, findSettings, checkLimit);\n\n        // Make an empty array for each batched query, per the dataloader contract\n        const results = entries.map(() => [] as T[]);\n        em[\"hydrateAndFinalize\"](type, rowData, {\n          sidecars: (entities) => {\n            preloadJoins?.forEach((j) => j.hydrator(rowData, entities));\n            // Put each row into the tagged query it matched\n            for (let i = 0; i < entities.length; i++) {\n              const entity = entities[i];\n              if (!entity.isDeletedEntity) {\n                for (const tag of rowData.get(i, \"_tags\")) results[tag].push(entity);\n              }\n            }\n          },\n        });\n        return results;\n      },\n      // Our filter/order tuple is a complex object, so use a stable cache key to ensure caching works.\n      { cacheKeyFn: queryFilterHash },\n    )\n    .load(prepared);\n}\n\n/**\n * Returns a stable cache key from the already-parsed query rather than the raw `where`.\n *\n * A scope `where` is an opaque proxy that `fastWhereFilterHash` can't serialize — but it doesn't need\n * to: by this point the scope's structure and values are already worked into the `ParsedFindQuery`, so\n * hashing that distinguishes e.g. `Author.adult` (age>=18) from `Author.senior` (age>=65) correctly.\n */\nexport function queryFilterHash(entry: { query: ParsedFindQuery; findSettings: object }): any {\n  return whereFilterHash({ query: entry.query, findSettings: entry.findSettings });\n}\n\nexport function whereFilterHash(where: object): any {\n  const key = fastWhereFilterHash(where);\n  if (key === undefined) throw new Error(\"fastWhereFilterHash could not serialize find filter\");\n  return key;\n}\n\n/** Filters pending-delete entities in place to avoid allocating a replacement array for the common find path. */\nexport function filterDeletedEntities<T extends Entity>(em: EntityManager, entities: T[]): T[] {\n  // Most EMs never delete entities, so skip even the findIndex scan until a delete has happened.\n  if (!getEmInternalApi(em).hasAnyDeletes()) return entities;\n\n  const firstDeleted = entities.findIndex((entity) => entity.isDeletedEntity);\n  if (firstDeleted === -1) return entities;\n\n  let writeIndex = firstDeleted;\n  for (let readIndex = firstDeleted + 1; readIndex < entities.length; readIndex++) {\n    const entity = entities[readIndex];\n    if (!entity.isDeletedEntity) {\n      entities[writeIndex++] = entity;\n    }\n  }\n  entities.length = writeIndex;\n  return entities;\n}\n\nclass ArgCounter {\n  private index = 0;\n  next(): number {\n    return this.index++;\n  }\n}\n\n/**\n * A single batched arg: the `_find` CTE column to create, plus the index into each entry's `bindings`\n * array that fills it. `bindingIndex` can differ from the column's position because inlined constants\n * are skipped — see {@link collectAndReplaceArgs}.\n */\nexport interface CteArg {\n  column: OpColumn;\n  bindingIndex: number;\n}\n\n/**\n * Rewrites each batched arg in `query` into a `_find.argX` placeholder.\n *\n * Any condition whose value(s) are identical across every batched query is left inline (using\n * query's condition as-is from entity0), so it renders as `col = ?` for better query planning.\n *\n * The returned array has the non-constant CTE columns, one {@link CteArg} per `_find.argX`.\n *\n * Because constants are skipped, the 1st CTE column (i.e. for last name) might actually have a\n * binding index of `1` if we've skipped an early constant column (i.e. first name).\n *\n * @param query the initial query in the batch, that all other queries structurally match\n * @param entries the values (bindings) for each query in the batch\n */\nexport function collectAndReplaceArgs(query: ParsedFindQuery, entries: readonly { bindings: any[] }[]): CteArg[] {\n  const args: CteArg[] = [];\n  const argsIndex = new ArgCounter();\n  // `bindings` were pushed in this same `visitConditions` order, so we can walk the conditions and\n  // each entry's `bindings` in lockstep, deciding per condition whether to inline or batch its value(s).\n  const constant = computeConstantBindings(entries);\n  let bindingIndex = 0;\n  visitConditions(query, {\n    visitCond(c: ColumnCondition) {\n      if (\"value\" in c.cond) {\n        const { kind } = c.cond;\n        // `between` consumes two bindings, everything else (incl. array `in`/`nin`) consumes one.\n        const consumed = kind === \"between\" ? 2 : 1;\n        const start = bindingIndex;\n        bindingIndex += consumed;\n        // If every batched query shares this condition's value(s), leave it as a normal `col = ?`\n        // condition (rendered from `entries[0]`'s value) instead of threading it through the CTE.\n        let allConstant = true;\n        for (let k = 0; k < consumed; k++) {\n          if (!constant[start + k]) {\n            allConstant = false;\n            break;\n          }\n        }\n        if (allConstant) return;\n        // `arg${args.length}` keeps the CTE column names in step with the `_find.argX` references that\n        // `rewriteToRawCondition` emits, since both only advance for the args we actually batch.\n        if (kind === \"between\") {\n          args.push({ column: { columnName: `arg${args.length}`, dbType: c.dbType }, bindingIndex: start });\n          args.push({ column: { columnName: `arg${args.length}`, dbType: c.dbType }, bindingIndex: start + 1 });\n        } else {\n          // Figure out the _find CTE's `unnest($n::${dbType})` so Postgres knows what we're sending in\n          const dbType =\n            kind === \"in\" || kind === \"nin\"\n              ? `${c.dbType}[]` // `in`/`nin` compare against an array column\n              : kind === \"jsonPathExists\" || kind === \"jsonPathPredicate\"\n                ? \"jsonpath\" // jsonPath needs `::jsonpath` (not `::jsonb`, which would be an invalid `jsonb @@ jsonb`)\n                : c.dbType;\n          args.push({ column: { columnName: `arg${args.length}`, dbType }, bindingIndex: start });\n        }\n        return rewriteToRawCondition(c, argsIndex);\n      } else if (c.cond.kind === \"is-null\" || c.cond.kind === \"not-null\") {\n        // leave it alone\n      } else {\n        throw new Error(\"Unsupported\");\n      }\n    },\n  });\n  return args;\n}\n\nfunction rewriteToRawCondition(c: ColumnCondition, argsIndex: ArgCounter): RawCondition {\n  const [op, negate] = makeOp(c.cond, argsIndex);\n  return {\n    kind: \"raw\",\n    aliases: [c.alias],\n    condition: `${negate ? \"NOT \" : \"\"}${kqDot(c.alias, c.column)} ${op}`,\n    pruneable: c.pruneable ?? false,\n    bindings: [],\n  };\n}\n\n/**\n * Builds the column-major values for the `_find` CTE.\n *\n * Column 0 is the per-entry `tag`; the remaining columns mirror `args` 1:1, each pulling its\n * `bindingIndex` from every entry's `bindings` (so inlined constants are naturally skipped).\n */\nexport function createColumnValuesFromPrepared(\n  args: readonly CteArg[],\n  entries: readonly { bindings: any[] }[],\n): any[][] {\n  const columnValues: any[][] = new Array(args.length + 1);\n  for (let i = 0; i < columnValues.length; i++) columnValues[i] = [];\n  entries.forEach((entry, i) => {\n    columnValues[0].push(i);\n    for (let k = 0; k < args.length; k++) {\n      columnValues[k + 1].push(entry.bindings[args[k].bindingIndex]);\n    }\n  });\n  return columnValues;\n}\n\n/** Pushes the arg values of a given query in the cross-query `bindings` array. */\nexport function collectValues(bindings: any[], query: ParsedFindQuery): void {\n  visitConditions(query, {\n    visitCond(c: ColumnCondition) {\n      if (\"value\" in c.cond) {\n        // between has two values\n        if (c.cond.kind === \"between\") {\n          bindings.push(c.cond.value[0]);\n          bindings.push(c.cond.value[1]);\n        } else {\n          bindings.push(c.cond.value);\n        }\n      }\n    },\n  });\n}\n\n/** Returns true for select expressions that do not need to be represented in GROUP BY. */\nfunction isAggregateSelect(select: string): boolean {\n  return select.toLowerCase().includes(\"array_agg(\");\n}\n\n/** Builds GROUP BYs for selected values, accounting for whole-row selects that are grouped by primary key. */\nfunction buildGroupBys(selects: ParsedSelect[]): ParsedGroupBy[] {\n  const sqlSelects = selects.map(selectSqlForGroupBy);\n  const wholeRowAliases = new Set(\n    sqlSelects\n      .filter((select) => !isAggregateSelect(select) && stripSelectAlias(select).endsWith(\".*\"))\n      .map(parseAlias),\n  );\n  return sqlSelects\n    .filter((select) => !isAggregateSelect(select))\n    .filter((select) => !isCoveredByWholeRowGroupBy(select, wholeRowAliases))\n    .map((select) => groupBySelect(select));\n}\n\n/** Returns a SQL string for group-by analysis, until we support bindings in ParsedGroupBy. */\nfunction selectSqlForGroupBy(select: ParsedSelect): string {\n  if (typeof select === \"string\") {\n    return select;\n  }\n  throw new Error(`find batching does not support grouped selects with bindings: ${select.sql}`);\n}\n\n/** Builds a GROUP BY for a selected value so `array_agg(_find.tag)` can coexist with plugin-rewritten selects. */\nfunction groupBySelect(select: string): ParsedGroupBy {\n  const expression = stripSelectAlias(select);\n  if (expression.endsWith(\".*\")) {\n    return { alias: parseAlias(expression), column: \"id\" };\n  }\n  return { expression };\n}\n\n/** Removes a trailing SQL alias from a select expression, i.e. `(a.id) as id` -> `(a.id)`. */\nfunction stripSelectAlias(select: string): string {\n  const match = /^(.*)\\s+as\\s+[^\\s]+$/i.exec(select);\n  return match?.[1] ?? select;\n}\n\n/** Returns true when an expression is functionally covered by an already-grouped whole-row alias. */\nfunction isCoveredByWholeRowGroupBy(select: string, wholeRowAliases: Set<string>): boolean {\n  const expression = stripSelectAlias(select);\n  if (expression.endsWith(\".*\")) {\n    return false;\n  }\n  const aliases = findSelectedAliases(expression);\n  return aliases.length > 0 && aliases.every((alias) => wholeRowAliases.has(alias));\n}\n\n/** Finds SQL aliases referenced as `alias.column` or `\"alias\".column`, i.e. `a.first_name` -> `a`. */\nfunction findSelectedAliases(expression: string): string[] {\n  const aliases = new Set<string>();\n  for (const match of expression.matchAll(/(?:\"([^\"]+)\"|([a-zA-Z_][\\w]*))\\./g)) {\n    aliases.add(match[1] ?? match[2]);\n  }\n  return [...aliases];\n}\n\n/** Returns [operator, argsTaken, negate], i.e. `[\"=\", 1, false]`. */\nfunction makeOp(cond: ParsedValueFilter<any>, argsIndex: ArgCounter): [string, boolean] {\n  switch (cond.kind) {\n    case \"eq\":\n    case \"ne\":\n    case \"gte\":\n    case \"gt\":\n    case \"lte\":\n    case \"lt\":\n    case \"like\":\n    case \"nlike\":\n    case \"ilike\":\n    case \"nilike\":\n    case \"regex\":\n    case \"nregex\":\n    case \"iregex\":\n    case \"niregex\":\n    case \"jsonPathExists\":\n    case \"jsonPathPredicate\":\n    case \"contains\":\n    case \"overlaps\":\n    case \"containedBy\": {\n      const fn = opToFn[cond.kind] ?? fail(`Invalid operator ${cond.kind}`);\n      return [`${fn} _find.arg${argsIndex.next()}`, false];\n    }\n    case \"noverlaps\":\n    case \"ncontains\": {\n      const fn = (opToFn as any)[cond.kind.substring(1)] ?? fail(`Invalid operator ${cond.kind}`);\n      return [`${fn} _find.arg${argsIndex.next()}`, true];\n    }\n    case \"is-null\":\n      return [`IS NULL`, false];\n    case \"not-null\":\n      return [`IS NOT NULL`, false];\n    case \"in\":\n      return [`= ANY(_find.arg${argsIndex.next()})`, false];\n    case \"nin\":\n      return [`!= ALL(_find.arg${argsIndex.next()})`, false];\n    case \"between\":\n      return [`BETWEEN _find.arg${argsIndex.next()} AND _find.arg${argsIndex.next()}`, false];\n    default:\n      assertNever(cond);\n  }\n}\n\n/**\n * Creates a `VALUES (...), (...)` SQL string for use in a CTE, typically for our\n * batch INSERTs/UPDATEs where the CTE is how we inject N rows of data/params into\n * the single INSERT/UPDATE statement.\n *\n * The caller is responsible for filling in the `bindings`, which should have 1\n * entry for each `rows x columns` cell.\n *\n * @deprecated Use newUnnestCte instead because it uses arrays to have a bounded number of parameters.\n */\nexport function buildValuesCte(\n  alias: string,\n  columns: { columnName: string; dbType: string }[],\n  rows: readonly any[],\n  // Should have a value for each `row x column` cell.\n  bindings: readonly any[],\n): ParsedCteClause {\n  return {\n    alias,\n    columns,\n    query: {\n      kind: \"raw\",\n      sql: `VALUES\n        ${rows.map((_, i) => `(${columns.map((c) => (i === 0 ? `?::${c.dbType}` : `?`)).join(\", \")})`).join(\", \")}\n      `,\n      bindings,\n    },\n  };\n}\n\n/** Returns, per binding slot, whether every batched query shares the same value. */\nfunction computeConstantBindings(entries: readonly { bindings: any[] }[]): boolean[] {\n  const length = entries[0].bindings.length;\n  const constant = new Array<boolean>(length);\n  for (let j = 0; j < length; j++) {\n    const first = entries[0].bindings[j];\n    let same = true;\n    for (let i = 1; i < entries.length; i++) {\n      if (!argsEqual(entries[i].bindings[j], first)) {\n        same = false;\n        break;\n      }\n    }\n    constant[j] = same;\n  }\n  return constant;\n}\n\n/**\n * Deep-equals two find-arg values (scalars, Dates, Temporals, or arrays thereof), reusing the same\n * scalar/array equality `setField` uses for change detection.\n *\n * Only used to decide whether a condition can be inlined, so false negatives are safe (we just fall\n * back to the CTE); we only return true when the values are genuinely equal.\n */\nfunction argsEqual(a: any, b: any): boolean {\n  return equal(a, b) || (Array.isArray(a) && Array.isArray(b) && equalArrays(a, b));\n}\n\nexport function getBatchKeyFromGenericStructure(meta: EntityMetadata, query: ParsedFindQuery): string {\n  // Temporarily swap condition values for `*` so we can see the generic structure of the query,\n  // then restore them; this avoids deep-cloning the entire parsed query on every em.find call.\n  // Track values per condition object b/c parseFindQuery does not deep copy complex conditions,\n  // i.e. `a.firstName.eq(...)`, so the same condition instance could appear twice.\n  const saved = new Map<any, any>();\n  visitConditions(query, {\n    visitCond(c: ColumnCondition) {\n      const { cond } = c;\n      if (\"value\" in cond && !saved.has(cond)) {\n        saved.set(cond, cond.value);\n        cond.value = \"*\";\n      }\n    },\n  });\n  const structure = JSON.stringify(query);\n  for (const [cond, value] of saved) cond.value = value;\n  // Include the meta b/c STI queries for different subtypes will look identical\n  return meta.stiDiscriminatorValue ? `${structure}|${meta.type}` : structure;\n}\n"],"mappings":"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"}

package/build/dataloaders/findDataLoader.d.cts

@@ -0,0 +1,79 @@
+import { ParsedCteClause, ParsedFindQuery } from "../queries/find/QueryParser.cjs";
+import { FilterAndSettings } from "../queries/find/EntityFilter.cjs";
+import { LoadHint } from "../loading/loadHints.cjs";
+import { OpColumn } from "../drivers/EntityWriter.cjs";
+import { EntityMetadata } from "../EntityMetadata.cjs";
+import { EntityManager, MaybeAbstractEntityConstructor } from "../EntityManager.cjs";
+import { Entity } from "../Entity.cjs";
+//#region src/dataloaders/findDataLoader.d.ts
+declare const findOperation = "find";
+declare function findDataLoader<T extends Entity>(em: EntityManager, type: MaybeAbstractEntityConstructor<T>, filter: FilterAndSettings<T>, hint: LoadHint<T> | undefined): Promise<T[]>;
+/**
+ * Returns a stable cache key from the already-parsed query rather than the raw `where`.
+ *
+ * A scope `where` is an opaque proxy that `fastWhereFilterHash` can't serialize — but it doesn't need
+ * to: by this point the scope's structure and values are already worked into the `ParsedFindQuery`, so
+ * hashing that distinguishes e.g. `Author.adult` (age>=18) from `Author.senior` (age>=65) correctly.
+ */
+declare function queryFilterHash(entry: {
+  query: ParsedFindQuery;
+  findSettings: object;
+}): any;
+declare function whereFilterHash(where: object): any;
+/** Filters pending-delete entities in place to avoid allocating a replacement array for the common find path. */
+declare function filterDeletedEntities<T extends Entity>(em: EntityManager, entities: T[]): T[];
+/**
+ * A single batched arg: the `_find` CTE column to create, plus the index into each entry's `bindings`
+ * array that fills it. `bindingIndex` can differ from the column's position because inlined constants
+ * are skipped — see {@link collectAndReplaceArgs}.
+ */
+interface CteArg {
+  column: OpColumn;
+  bindingIndex: number;
+}
+/**
+ * Rewrites each batched arg in `query` into a `_find.argX` placeholder.
+ *
+ * Any condition whose value(s) are identical across every batched query is left inline (using
+ * query's condition as-is from entity0), so it renders as `col = ?` for better query planning.
+ *
+ * The returned array has the non-constant CTE columns, one {@link CteArg} per `_find.argX`.
+ *
+ * Because constants are skipped, the 1st CTE column (i.e. for last name) might actually have a
+ * binding index of `1` if we've skipped an early constant column (i.e. first name).
+ *
+ * @param query the initial query in the batch, that all other queries structurally match
+ * @param entries the values (bindings) for each query in the batch
+ */
+declare function collectAndReplaceArgs(query: ParsedFindQuery, entries: readonly {
+  bindings: any[];
+}[]): CteArg[];
+/**
+ * Builds the column-major values for the `_find` CTE.
+ *
+ * Column 0 is the per-entry `tag`; the remaining columns mirror `args` 1:1, each pulling its
+ * `bindingIndex` from every entry's `bindings` (so inlined constants are naturally skipped).
+ */
+declare function createColumnValuesFromPrepared(args: readonly CteArg[], entries: readonly {
+  bindings: any[];
+}[]): any[][];
+/** Pushes the arg values of a given query in the cross-query `bindings` array. */
+declare function collectValues(bindings: any[], query: ParsedFindQuery): void;
+/**
+ * Creates a `VALUES (...), (...)` SQL string for use in a CTE, typically for our
+ * batch INSERTs/UPDATEs where the CTE is how we inject N rows of data/params into
+ * the single INSERT/UPDATE statement.
+ *
+ * The caller is responsible for filling in the `bindings`, which should have 1
+ * entry for each `rows x columns` cell.
+ *
+ * @deprecated Use newUnnestCte instead because it uses arrays to have a bounded number of parameters.
+ */
+declare function buildValuesCte(alias: string, columns: {
+  columnName: string;
+  dbType: string;
+}[], rows: readonly any[], bindings: readonly any[]): ParsedCteClause;
+declare function getBatchKeyFromGenericStructure(meta: EntityMetadata, query: ParsedFindQuery): string;
+//#endregion
+export { CteArg, buildValuesCte, collectAndReplaceArgs, collectValues, createColumnValuesFromPrepared, filterDeletedEntities, findDataLoader, findOperation, getBatchKeyFromGenericStructure, queryFilterHash, whereFilterHash };
+//# sourceMappingURL=findDataLoader.d.cts.map

package/build/dataloaders/findDataLoader.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findDataLoader.d.cts","names":[],"sources":["../../src/dataloaders/findDataLoader.ts"],"mappings":";;;;;;;;cA0Ba;iBAUG,eAAe,UAAU,QACvC,IAAI,eACJ,MAAM,+BAA+B,IACrC,QAAQ,kBAAkB,IAC1B,MAAM,SAAS,iBACd,QAAQ;;;;;;;;iBAwHK,gBAAgB;EAAS,OAAO;EAAiB;;iBAIjD,gBAAgB;;iBAOhB,sBAAsB,UAAU,QAAQ,IAAI,eAAe,UAAU,MAAM;;;;;;UA8B1E;EACf,QAAQ;EACR;;;;;;;;;;;;;;;;iBAiBc,sBAAsB,OAAO,iBAAiB;EAAoB;MAAsB;;;;;;;iBAoExF,+BACd,eAAe,UACf;EAAoB;;;iBAcN,cAAc,iBAAiB,OAAO;;;;;;;;;;;iBAoItC,eACd,eACA;EAAW;EAAoB;KAC/B,sBAEA,2BACC;iBA2Ca,gCAAgC,MAAM,gBAAgB,OAAO"}

package/build/dataloaders/findDataLoader.d.mts

@@ -0,0 +1,79 @@
+import { ParsedCteClause, ParsedFindQuery } from "../queries/find/QueryParser.mjs";
+import { FilterAndSettings } from "../queries/find/EntityFilter.mjs";
+import { LoadHint } from "../loading/loadHints.mjs";
+import { OpColumn } from "../drivers/EntityWriter.mjs";
+import { EntityMetadata } from "../EntityMetadata.mjs";
+import { EntityManager, MaybeAbstractEntityConstructor } from "../EntityManager.mjs";
+import { Entity } from "../Entity.mjs";
+//#region src/dataloaders/findDataLoader.d.ts
+declare const findOperation = "find";
+declare function findDataLoader<T extends Entity>(em: EntityManager, type: MaybeAbstractEntityConstructor<T>, filter: FilterAndSettings<T>, hint: LoadHint<T> | undefined): Promise<T[]>;
+/**
+ * Returns a stable cache key from the already-parsed query rather than the raw `where`.
+ *
+ * A scope `where` is an opaque proxy that `fastWhereFilterHash` can't serialize — but it doesn't need
+ * to: by this point the scope's structure and values are already worked into the `ParsedFindQuery`, so
+ * hashing that distinguishes e.g. `Author.adult` (age>=18) from `Author.senior` (age>=65) correctly.
+ */
+declare function queryFilterHash(entry: {
+  query: ParsedFindQuery;
+  findSettings: object;
+}): any;
+declare function whereFilterHash(where: object): any;
+/** Filters pending-delete entities in place to avoid allocating a replacement array for the common find path. */
+declare function filterDeletedEntities<T extends Entity>(em: EntityManager, entities: T[]): T[];
+/**
+ * A single batched arg: the `_find` CTE column to create, plus the index into each entry's `bindings`
+ * array that fills it. `bindingIndex` can differ from the column's position because inlined constants
+ * are skipped — see {@link collectAndReplaceArgs}.
+ */
+interface CteArg {
+  column: OpColumn;
+  bindingIndex: number;
+}
+/**
+ * Rewrites each batched arg in `query` into a `_find.argX` placeholder.
+ *
+ * Any condition whose value(s) are identical across every batched query is left inline (using
+ * query's condition as-is from entity0), so it renders as `col = ?` for better query planning.
+ *
+ * The returned array has the non-constant CTE columns, one {@link CteArg} per `_find.argX`.
+ *
+ * Because constants are skipped, the 1st CTE column (i.e. for last name) might actually have a
+ * binding index of `1` if we've skipped an early constant column (i.e. first name).
+ *
+ * @param query the initial query in the batch, that all other queries structurally match
+ * @param entries the values (bindings) for each query in the batch
+ */
+declare function collectAndReplaceArgs(query: ParsedFindQuery, entries: readonly {
+  bindings: any[];
+}[]): CteArg[];
+/**
+ * Builds the column-major values for the `_find` CTE.
+ *
+ * Column 0 is the per-entry `tag`; the remaining columns mirror `args` 1:1, each pulling its
+ * `bindingIndex` from every entry's `bindings` (so inlined constants are naturally skipped).
+ */
+declare function createColumnValuesFromPrepared(args: readonly CteArg[], entries: readonly {
+  bindings: any[];
+}[]): any[][];
+/** Pushes the arg values of a given query in the cross-query `bindings` array. */
+declare function collectValues(bindings: any[], query: ParsedFindQuery): void;
+/**
+ * Creates a `VALUES (...), (...)` SQL string for use in a CTE, typically for our
+ * batch INSERTs/UPDATEs where the CTE is how we inject N rows of data/params into
+ * the single INSERT/UPDATE statement.
+ *
+ * The caller is responsible for filling in the `bindings`, which should have 1
+ * entry for each `rows x columns` cell.
+ *
+ * @deprecated Use newUnnestCte instead because it uses arrays to have a bounded number of parameters.
+ */
+declare function buildValuesCte(alias: string, columns: {
+  columnName: string;
+  dbType: string;
+}[], rows: readonly any[], bindings: readonly any[]): ParsedCteClause;
+declare function getBatchKeyFromGenericStructure(meta: EntityMetadata, query: ParsedFindQuery): string;
+//#endregion
+export { CteArg, buildValuesCte, collectAndReplaceArgs, collectValues, createColumnValuesFromPrepared, filterDeletedEntities, findDataLoader, findOperation, getBatchKeyFromGenericStructure, queryFilterHash, whereFilterHash };
+//# sourceMappingURL=findDataLoader.d.mts.map

package/build/dataloaders/findDataLoader.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findDataLoader.d.mts","names":[],"sources":["../../src/dataloaders/findDataLoader.ts"],"mappings":";;;;;;;;cA0Ba;iBAUG,eAAe,UAAU,QACvC,IAAI,eACJ,MAAM,+BAA+B,IACrC,QAAQ,kBAAkB,IAC1B,MAAM,SAAS,iBACd,QAAQ;;;;;;;;iBAwHK,gBAAgB;EAAS,OAAO;EAAiB;;iBAIjD,gBAAgB;;iBAOhB,sBAAsB,UAAU,QAAQ,IAAI,eAAe,UAAU,MAAM;;;;;;UA8B1E;EACf,QAAQ;EACR;;;;;;;;;;;;;;;;iBAiBc,sBAAsB,OAAO,iBAAiB;EAAoB;MAAsB;;;;;;;iBAoExF,+BACd,eAAe,UACf;EAAoB;;;iBAcN,cAAc,iBAAiB,OAAO;;;;;;;;;;;iBAoItC,eACd,eACA;EAAW;EAAoB;KAC/B,sBAEA,2BACC;iBA2Ca,gCAAgC,MAAM,gBAAgB,OAAO"}