@pattern-stack/codegen 0.27.1 → 0.27.3

package/dist/runtime/subsystems/jobs/jobs-domain.module.js

@@ -1,13 +1,13 @@
 import {
   JobsDomainModule
-} from "../../../chunk-KS4BZHIA.js";
-import "../../../chunk-BHZP6LOV.js";
+} from "../../../chunk-XW4XKN3F.js";
 import "../../../chunk-DV4RV2DC.js";
 import "../../../chunk-E6PLM6QG.js";
 import "../../../chunk-VQOAATIG.js";
 import "../../../chunk-PNZSGAB2.js";
-import "../../../chunk-SNQ3TOWP.js";
 import "../../../chunk-VNBC3VXM.js";
+import "../../../chunk-BHZP6LOV.js";
+import "../../../chunk-SNQ3TOWP.js";
 import "../../../chunk-T4BIIU5E.js";
 import "../../../chunk-L3LZWWSX.js";
 import "../../../chunk-I6MVCB5A.js";

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;
 		},
 	};
 }