@pattern-stack/codegen 0.27.2 → 0.27.3

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.27.3] — 2026-06-13
+
+### Fixed
+
+- **Frontend lookups/resolver hydration no longer full-fetches every entity —
+  the LANDMINE-1 OOM guard.** `buildLookupsAsync` (store/lookups.ts) and
+  `hydrateResolverCache` (store/resolvers.ts) paged the COMPLETE table of *every*
+  entity via `api.listAll()` on the first `useData()` mount of *any* route, to
+  populate cross-entity FK-resolution maps. On a large content table this is
+  catastrophic: a swe-brain mailbox of 21,648 emails × ~33 KB `bodyHtml` pulled
+  ~700 MB into the renderer and the browser silently OOM-killed the tab — on
+  every route, including ones that never read email. Dogfood discovery from
+  swe-brain. Fix: full-fetch an entity only if it is a **lookup target** (some
+  `belongs_to` resolves it by id → it backs a FieldMeta `reference`) **or** it
+  has no unbounded text column; heavy, non-target entities (a `text` field, or a
+  `string` with no `max_length`) are seeded from current collection state
+  instead — nothing resolves them by id, so the current page is all any consumer
+  can use. `api` imports for skipped entities are dropped so none dangle. See
+  `lookupFullFetchNames` in `emit-store.ts`. Known edge: an entity consumed as a
+  lookup ONLY via hand-authored `lookups.<plural>` access (not a FieldMeta
+  reference) that *also* has an unbounded string column would be skipped — give
+  it a bounded `max_length` or declare the FK so it registers as a target.
+
 ## [0.27.2] — 2026-06-08
 
 ### Fixed

package/dist/src/cli/index.js

@@ -5729,6 +5729,21 @@ function resolvableRels(entity, ctx) {
 function fkField(rel2) {
   return rel2.foreignKey && rel2.foreignKey.length > 0 ? rel2.foreignKey : `${rel2.target}_id`;
 }
+function lookupFullFetchNames(ctx) {
+  const referenceTargets = /* @__PURE__ */ new Set();
+  for (const e of ctx.entities) {
+    for (const r of resolvableRels(e, ctx)) referenceTargets.add(r.target.name);
+  }
+  const out = /* @__PURE__ */ new Set();
+  for (const e of ctx.entities) {
+    const parsed = ctx.parsed.get(e.name);
+    const hasUnboundedText = parsed ? Array.from(parsed.fields.values()).some(
+      (f) => f.type === "text" || f.type === "string" && f.constraints.maxLength === void 0
+    ) : false;
+    if (referenceTargets.has(e.name) || !hasUnboundedText) out.add(e.name);
+  }
+  return out;
+}
 function buildStoreIndexFile(ctx) {
   const entities = sortEntities(ctx.entities);
   const hookImports = entities.map((e) => `import { ${e.camelName}Hooks } from '../entities/${e.name}';`).join("\n");
@@ -5781,8 +5796,10 @@ export type AppStore = typeof store;
 }
 function buildResolversFile(ctx) {
   const entities = sortEntities(ctx.entities);
+  const fullFetch = lookupFullFetchNames(ctx);
+  const fetched = entities.filter((e) => fullFetch.has(e.name));
   const collectionImports = entities.map((e) => `import { ${e.camelName}Collection } from '../collections/${e.name}';`).join("\n");
-  const apiImports = entities.map((e) => `import { ${e.camelName}Api } from '../api/${e.name}';`).join("\n");
+  const apiImports = fetched.map((e) => `import { ${e.camelName}Api } from '../api/${e.name}';`).join("\n");
   const typeImports = entities.map((e) => `import type { ${e.className} } from '${ctx.config.dbEntitiesImport}/${e.name}';`).join("\n");
   const resolverIface = entities.map(
     (e) => `	${e.camelName}: (id: string | null | undefined) => ${e.className} | undefined;`
@@ -5795,7 +5812,7 @@ function buildResolversFile(ctx) {
 		},`
   ).join("\n");
   const hydrationCacheFields = entities.map((e) => `	${e.camelName}: new Map<string, ${e.className}>(),`).join("\n");
-  const hydrationCalls = entities.map(
+  const hydrationCalls = fetched.map(
     (e) => `		${e.camelName}Api.listAll().then((rows) => {
 			hydrationCache.${e.camelName} = new Map(rows.map((r) => [r.id as string, r]));
 		}),`
@@ -5884,22 +5901,34 @@ ${refsSection}`;
 }
 function buildLookupsFile(ctx) {
   const entities = sortEntities(ctx.entities);
+  const fullFetch = lookupFullFetchNames(ctx);
+  const fetched = entities.filter((e) => fullFetch.has(e.name));
   const collectionImports = entities.map((e) => `import { ${e.camelName}Collection } from '../collections/${e.name}';`).join("\n");
-  const apiImports = entities.map((e) => `import { ${e.camelName}Api } from '../api/${e.name}';`).join("\n");
+  const apiImports = fetched.map((e) => `import { ${e.camelName}Api } from '../api/${e.name}';`).join("\n");
   const typeImports = entities.map((e) => `import type { ${e.className} } from '${ctx.config.dbEntitiesImport}/${e.name}';`).join("\n");
   const lookupIface = entities.map((e) => `	${e.plural}: Map<string, ${e.className}>;`).join("\n");
-  const lookupBuild = entities.map(
-    (e) => `		${e.plural}: new Map(
+  const collectionStateMap = (e) => `		${e.plural}: new Map(
 			Array.from(${e.camelName}Collection.state.values()).map((item) => [
 				(item as ${e.className}).id as string,
 				item as ${e.className},
 			]),
-		),`
-  ).join("\n");
-  const lookupBuildAsyncDecls = entities.map((e) => `		${e.camelName}Api.listAll(),`).join("\n");
-  const lookupBuildAsyncFields = entities.map(
-    (e, i) => `		${e.plural}: new Map(rows[${i}].map((r) => [r.id as string, r as ${e.className}])),`
-  ).join("\n");
+		),`;
+  const lookupBuild = entities.map(collectionStateMap).join("\n");
+  const lookupBuildAsyncDecls = fetched.map((e) => `		${e.camelName}Api.listAll(),`).join("\n");
+  const fetchedIndex = new Map(fetched.map((e, i) => [e.name, i]));
+  const lookupBuildAsyncFields = entities.map((e) => {
+    const i = fetchedIndex.get(e.name);
+    return i === void 0 ? collectionStateMap(e) : `		${e.plural}: new Map(rows[${i}].map((r) => [r.id as string, r as ${e.className}])),`;
+  }).join("\n");
+  const lookupBuildAsyncBody = fetched.length > 0 ? `	const rows = await Promise.all([
+${lookupBuildAsyncDecls}
+	]);
+	return {
+${lookupBuildAsyncFields}
+	};` : `	await Promise.resolve();
+	return {
+${lookupBuildAsyncFields}
+	};`;
   const body = `${collectionImports}
 ${apiImports}
 ${typeImports}
@@ -5923,12 +5952,7 @@ ${lookupBuild}
  * may not be on the current page.
  */
 export async function buildLookupsAsync(): Promise<EntityLookups> {
-	const rows = await Promise.all([
-${lookupBuildAsyncDecls}
-	]);
-	return {
-${lookupBuildAsyncFields}
-	};
+${lookupBuildAsyncBody}
 }
 
 /**
@@ -5938,20 +5962,40 @@ ${lookupBuildAsyncFields}
  */
 export function createLookups() {
 	let cache: EntityLookups | null = null;
+	// Run-once guard for \`hydrate()\`. The store runtime calls hydrate from a
+	// per-mount useEffect with NO dedup, so without this every EntityList/useData
+	// mount (x2 under React StrictMode) kicks off another full buildLookupsAsync()
+	// \u2014 a listAll() of every entity. On a large table (tens of thousands of rows)
+	// that slurps the whole table N times concurrently and can OOM the renderer.
+	// The guard collapses all callers onto a single hydration: cache the resolved
+	// set, and dedupe concurrent callers onto one in-flight promise. \`clear()\`
+	// forces a refresh. NOTE: this caps the damage but does not make full-fetching
+	// a huge table cheap \u2014 lazy/on-demand FK resolution is the deeper fix.
+	let inFlight: Promise<EntityLookups> | null = null;
 	return {
 		build: (): EntityLookups => {
 			cache = buildLookups();
 			return cache;
 		},
 		hydrate: async (): Promise<EntityLookups> => {
-			cache = await buildLookupsAsync();
-			return cache;
+			if (cache) return cache;
+			if (inFlight) return inFlight;
+			inFlight = buildLookupsAsync()
+				.then((result) => {
+					cache = result;
+					return result;
+				})
+				.finally(() => {
+					inFlight = null;
+				});
+			return inFlight;
 		},
 		get current(): EntityLookups | null {
 			return cache;
 		},
 		clear: (): void => {
 			cache = null;
+			inFlight = null;
 		},
 	};
 }