@vibeorm/runtime 1.3.0 → 2.0.0-alpha.2

package/src/coerce.ts

@@ -1,184 +0,0 @@
-/**
- * Scalar value type coercion.
- *
- * Coerce raw DB driver output to the JS types declared in the Prisma schema.
- * Currently handles `BigInt` (pg / bun:sql return PG `bigint` as a string,
- * but the application expects native `BigInt`).
- *
- * Lives in its own module so all relation loaders (query strategy, lateral
- * join strategy, post-write refresh, raw post-processing) can call it without
- * creating circular imports between `client.ts` and the relation loaders.
- *
- * Mutates the records in place — callers rely on this for performance.
- */
-
-import type { ModelMeta, ScalarFieldMeta } from "./types.ts";
-
-/**
- * Per-model cache of names of fields that need BigInt coercion.
- * Empty arrays are cached too, so the `length === 0` fast path costs one
- * `WeakMap.get` after the first call per model.
- *
- * Keyed by the `scalarFields` array reference (the same hot-path cache key
- * used by `getScalarFieldMap`), which is stable for the process lifetime
- * because model metadata is generated once at startup.
- */
-const _bigintFieldsCache = new WeakMap<
-  readonly ScalarFieldMeta[],
-  readonly string[]
->();
-
-function getBigIntFieldNames(modelMeta: ModelMeta): readonly string[] {
-  const sf = modelMeta.scalarFields;
-  let names = _bigintFieldsCache.get(sf);
-  if (names) return names;
-  const arr: string[] = [];
-  for (const f of sf) {
-    if ((f as { type?: string }).type === "BigInt") arr.push(f.name);
-  }
-  names = arr;
-  _bigintFieldsCache.set(sf, names);
-  return names;
-}
-
-/**
- * Per-model cache of enum-array field names. Same WeakMap shape and
- * lifetime guarantees as `_bigintFieldsCache`.
- *
- * Enum-array columns need post-processing because neither `bun:sql` nor
- * `node-postgres` knows the user-defined enum's array type OID, so the
- * driver returns the raw PG array literal as a string (e.g. `"{ADMIN,USER}"`)
- * instead of a JS array. Built-in scalar arrays (`text[]`, `int4[]`, …) ARE
- * parsed by both drivers because their OIDs are well-known.
- */
-const _enumListFieldsCache = new WeakMap<
-  readonly ScalarFieldMeta[],
-  readonly string[]
->();
-
-function getEnumListFieldNames(modelMeta: ModelMeta): readonly string[] {
-  const sf = modelMeta.scalarFields;
-  let names = _enumListFieldsCache.get(sf);
-  if (names) return names;
-  const arr: string[] = [];
-  for (const f of sf) {
-    if (f.kind === "enum" && f.isList === true) arr.push(f.name);
-  }
-  names = arr;
-  _enumListFieldsCache.set(sf, names);
-  return names;
-}
-
-/**
- * Parse a PostgreSQL array literal string into a JS array of strings.
- *
- * Format: `{val1,val2,"quoted,val",NULL,...}` with `""` quoting only when an
- * element contains commas, double-quotes, backslashes, or is the literal
- * `NULL`. PG uses backslash-escaping inside quoted elements.
- *
- * Returns `[]` for `{}`. Returns the input unchanged if it doesn't look like
- * an array literal (defensive — should never happen for an enum-array column).
- */
-function parsePgArrayLiteral(literal: string): string[] | string {
-  if (literal.length < 2 || literal.charCodeAt(0) !== 123 /* { */) return literal;
-  if (literal === "{}") return [];
-
-  const out: string[] = [];
-  const inner = literal.slice(1, -1);
-  let i = 0;
-  const len = inner.length;
-  while (i < len) {
-    if (inner.charCodeAt(i) === 34 /* " */) {
-      // Quoted element — read until matching close-quote, honouring \\ and \"
-      let s = "";
-      i++;
-      while (i < len) {
-        const ch = inner.charCodeAt(i);
-        if (ch === 92 /* \ */) {
-          s += inner[i + 1] ?? "";
-          i += 2;
-        } else if (ch === 34) {
-          i++;
-          break;
-        } else {
-          s += inner[i];
-          i++;
-        }
-      }
-      out.push(s);
-    } else {
-      // Unquoted element — read until next comma or end
-      let s = "";
-      while (i < len && inner.charCodeAt(i) !== 44 /* , */) {
-        s += inner[i];
-        i++;
-      }
-      out.push(s);
-    }
-    if (i < len && inner.charCodeAt(i) === 44 /* , */) i++;
-  }
-  return out;
-}
-
-/**
- * Coerce scalar field values on the given records to their JS-native types.
- *
- * Today only `BigInt` fields are affected. Driver behaviour:
- *  - `bun:sql` returns PG `bigint` as a JS `string`.
- *  - `node-postgres` returns PG `bigint` as a JS `string` by default too.
- *  - In both cases the Prisma type is `BigInt`, so we coerce.
- *
- * No-op when the model has no `BigInt` fields, or when `records` is empty.
- */
-export function coerceFieldTypes(params: {
-  records: Record<string, unknown>[];
-  modelMeta: ModelMeta;
-}): void {
-  const { records, modelMeta } = params;
-  if (records.length === 0) return;
-
-  const bigintNames = getBigIntFieldNames(modelMeta);
-  const enumListNames = getEnumListFieldNames(modelMeta);
-  if (bigintNames.length === 0 && enumListNames.length === 0) return;
-
-  for (const record of records) {
-    for (const name of bigintNames) {
-      const val = record[name];
-      if (typeof val === "string") {
-        record[name] = BigInt(val);
-      } else if (typeof val === "number") {
-        record[name] = BigInt(val);
-      }
-    }
-    // Enum-array fields arrive as raw PG array literal strings from both
-    // bun:sql and node-postgres (the driver doesn't know the user-defined
-    // enum's array OID). Parse them into JS string arrays. Bug 2 + Bug 3.
-    for (const name of enumListNames) {
-      const val = record[name];
-      if (typeof val === "string") {
-        const parsed = parsePgArrayLiteral(val);
-        if (Array.isArray(parsed)) record[name] = parsed;
-      }
-    }
-  }
-}
-
-/**
- * True iff the model has any `BigInt` fields that require coercion.
- * Cheap O(1) lookup after first call per model. Hot-path callers (lateral-join
- * builder, relation loaders) use this to skip the per-row coercion loop
- * entirely for relations whose related model has no `BigInt` columns.
- */
-export function modelHasBigInt(modelMeta: ModelMeta): boolean {
-  return getBigIntFieldNames(modelMeta).length > 0;
-}
-
-/**
- * True iff the model has any fields that need post-driver coercion
- * (BigInt OR enum-array). Use this in place of `modelHasBigInt` whenever
- * the fast-path skip would otherwise miss enum-array fields (Bug 2).
- */
-export function modelNeedsCoercion(modelMeta: ModelMeta): boolean {
-  return getBigIntFieldNames(modelMeta).length > 0
-    || getEnumListFieldNames(modelMeta).length > 0;
-}

package/src/count-loader.ts

@@ -1,152 +0,0 @@
-/**
- * Shared `_count` resolution + loader, used by both the "query" and "join"
- * relation strategies.
- *
- * `resolveCountSpec` looks at `include._count` / `select._count` and returns
- * the list of list-relation names to count (or `["__all__"]` for `_count: true`,
- * or `null` when not requested).
- *
- * `loadRelationCounts` issues a single grouped `COUNT(*) GROUP BY <fk>` per
- * relation (parallelised across relations) and attaches the result as a
- * `_count` object on each parent record.
- *
- * Lives in its own module so the lateral-join path can call it without
- * pulling in `client.ts` (which would create a circular import).
- */
-
-import type { ModelMeta, ModelMetaMap } from "./types.ts";
-import { getScalarFieldMap, getModelByNameMap, PgArray } from "./types.ts";
-
-type SqlExecutor = (params: {
-  text: string;
-  values: unknown[];
-}) => Promise<Record<string, unknown>[]>;
-
-/**
- * Resolve `_count` specification from `include` or `select` args.
- * Returns the list of relation names to count, `["__all__"]` to count every
- * list relation, or `null` if `_count` was not requested.
- */
-export function resolveCountSpec(params: { args: Record<string, unknown> }): string[] | null {
-  const { args } = params;
-  const include = args.include as Record<string, unknown> | undefined;
-  const select = args.select as Record<string, unknown> | undefined;
-
-  const countArg = include?._count ?? select?._count;
-  if (!countArg) return null;
-
-  if (countArg === true) {
-    // Count all list relations — will be resolved by loadRelationCounts
-    return ["__all__"];
-  }
-
-  if (typeof countArg === "object" && countArg !== null) {
-    const countObj = countArg as Record<string, unknown>;
-    const selectObj = countObj.select as Record<string, boolean> | undefined;
-    if (selectObj) {
-      return Object.entries(selectObj)
-        .filter(([_, enabled]) => enabled)
-        .map(([name]) => name);
-    }
-  }
-
-  return null;
-}
-
-/**
- * Load relation counts and attach a `_count` object to each parent record.
- * Uses one grouped `COUNT(*)` query per relation, executed in parallel.
- *
- * Mutates the parent records in place.
- */
-export async function loadRelationCounts(params: {
-  records: Record<string, unknown>[];
-  modelMeta: ModelMeta;
-  allModelsMeta: ModelMetaMap;
-  countSpec: string[];
-  executor: SqlExecutor;
-}): Promise<void> {
-  const { records, modelMeta, allModelsMeta, countSpec, executor } = params;
-  const modelMap = getModelByNameMap({ allModelsMeta });
-  const parentPk = modelMeta.primaryKey[0];
-  if (!parentPk) return;
-
-  const parentIds = records.map((r) => r[parentPk]).filter((id) => id != null);
-  if (parentIds.length === 0) return;
-
-  // Resolve which relations to count
-  const listRelations = modelMeta.relationFields.filter((r) => r.isList);
-  const relationsToCount = countSpec.includes("__all__")
-    ? listRelations
-    : listRelations.filter((r) => countSpec.includes(r.name));
-
-  // Initialize _count on all records
-  for (const record of records) {
-    const countObj: Record<string, number> = {};
-    for (const rel of relationsToCount) {
-      countObj[rel.name] = 0;
-    }
-    record._count = countObj;
-  }
-
-  // Run all relation COUNT queries in parallel — each hits a different table
-  // so there are no data races on the parent records.
-  await Promise.all(
-    relationsToCount.map(async (rel) => {
-      const relatedModelMeta = modelMap.get(rel.relatedModel);
-      if (!relatedModelMeta) return;
-
-      // M:N relation: count via join table
-      if (rel.type === "manyToMany" && (rel as { joinTable?: string }).joinTable) {
-        const joinTableName = (rel as { joinTable?: string }).joinTable!;
-        const sorted = [modelMeta.name, relatedModelMeta.name].sort();
-        const parentIsA = modelMeta.name === sorted[0];
-        const parentCol = parentIsA ? "A" : "B";
-
-        const text = `SELECT "${joinTableName}"."${parentCol}" AS "__fk", COUNT(*) AS "__count" FROM "${joinTableName}" WHERE "${joinTableName}"."${parentCol}" = ANY($1) GROUP BY "${joinTableName}"."${parentCol}"`;
-        const result = await executor({ text, values: [new PgArray(parentIds)] });
-
-        const countMap = new Map<unknown, number>();
-        for (const row of result) {
-          countMap.set(row.__fk, Number(row.__count ?? 0));
-        }
-
-        for (const record of records) {
-          const pkValue = record[parentPk];
-          const cnt = countMap.get(pkValue) ?? 0;
-          (record._count as Record<string, number>)[rel.name] = cnt;
-        }
-        return;
-      }
-
-      // Find the FK column on the related model (with relationName disambiguation)
-      const reverseRel = relatedModelMeta.relationFields.find(
-        (r) => r.relatedModel === modelMeta.name && r.isForeignKey && r.fields.length > 0 &&
-          (!rel.relationName || r.relationName === rel.relationName)
-      );
-      if (!reverseRel) return;
-
-      const fkField = reverseRel.fields[0]!;
-      const relatedSfMap = getScalarFieldMap({ scalarFields: relatedModelMeta.scalarFields });
-      const fkScalar = relatedSfMap.get(fkField);
-      const fkDbName = fkScalar?.dbName ?? fkField;
-      const relatedTable = `"${relatedModelMeta.dbName}"`;
-
-      // SELECT "fk" AS "__fk", COUNT(*) AS "__count" FROM "related" WHERE "fk" = ANY($1) GROUP BY "fk"
-      const text = `SELECT ${relatedTable}."${fkDbName}" AS "__fk", COUNT(*) AS "__count" FROM ${relatedTable} WHERE ${relatedTable}."${fkDbName}" = ANY($1) GROUP BY ${relatedTable}."${fkDbName}"`;
-      const result = await executor({ text, values: [new PgArray(parentIds)] });
-
-      // Map counts back to parent records
-      const countMap = new Map<unknown, number>();
-      for (const row of result) {
-        countMap.set(row.__fk, Number(row.__count ?? 0));
-      }
-
-      for (const record of records) {
-        const pkValue = record[parentPk];
-        const cnt = countMap.get(pkValue) ?? 0;
-        (record._count as Record<string, number>)[rel.name] = cnt;
-      }
-    })
-  );
-}