@aventara/build 1.0.0-rc.10 → 1.0.0-rc.12

package/CHANGELOG.md

@@ -1,5 +1,57 @@
 # @aventara/build
 
+## 1.0.0-rc.12
+
+### Patch Changes
+
+- Updated dependencies [afd5eda]
+- Updated dependencies [fdeee8a]
+  - @aventara/client@1.0.0-rc.12
+  - @aventara/core@1.0.0-rc.12
+
+## 1.0.0-rc.11
+
+### Patch Changes
+
+- 6197c08: `@/aventara/universal`'s calls are the generated client's own calls again. The entry no longer wraps each one in
+  `io().then(call)`, so its own `signal`, `avClient.all`'s `signal` and strict abort, and `avLazy` all reach it, in the
+  browser and on the server. Next's `io()` is now awaited before the request is sent.
+
+  In the browser, the calls made in one tick are still grouped into one `/_all`. On the server, none is grouped: each
+  call has a client of its own with grouping off, and it is sent from the async context of the code that made it. Before,
+  one queue served every request. Calls from two concurrent requests, or a call inside `unstable_cache` and one outside
+  it, could share a flush and run with the first call's headers and `state`.
+
+  `avLazy` no longer keeps one answer for every request on a server:
+
+  - The generated client's `avLazy` keeps its answer in a page. On a server (no `location`) it keeps none, and each await
+    makes the call again.
+  - `@aventara/core`'s `avLazy` keeps none: each await makes the call again.
+  - `@/aventara/universal` now exports its own `avLazy`, which keeps one answer per request inside a React render
+    (React's `cache`, which the entry now imports) and none where React keeps no request.
+
+  Before, an `avLazy` made at module scope handed the first request's answer to every request after it.
+
+  `ready()`'s in-process path now splits a cached read's GET URL into its path and its `?q=&v=` query, with an empty
+  body, so the read reaches its GET route instead of being answered as absent.
+
+- 0b2f077: `aventara-build` reads `server-only` as an empty module, as a Next.js server bundle does. A `src/aventara/config.ts`
+  that imports it, or imports a module that does, now builds; before, the package threw outside the `react-server`
+  condition and the build refused the configuration ("could not be run: This module cannot be imported from a Client
+  Component module").
+- Updated dependencies [6197c08]
+- Updated dependencies [5ac10f7]
+- Updated dependencies [e0e89c1]
+- Updated dependencies [186bc29]
+- Updated dependencies [33b5f83]
+- Updated dependencies [6d8b589]
+- Updated dependencies [11ece49]
+- Updated dependencies [92fd093]
+- Updated dependencies [e5e98e6]
+- Updated dependencies [a05d970]
+  - @aventara/client@1.0.0-rc.11
+  - @aventara/core@1.0.0-rc.11
+
 ## 1.0.0-rc.10
 
 ### Patch Changes

package/dist/client/client-file.js

@@ -12,7 +12,7 @@ const ENTRY_BANNER = [
 ].join("\n");
 export const SERVER_CALL_REFUSAL = "avClient from @/aventara/client runs in the browser only, and this call ran on the server, where a Client Component renders first: on the server, call avClient from @/aventara/server, or from @/aventara/universal for data the browser then hydrates.";
 const BROWSER_GUARD_SOURCE = `/** \`call\`, rejected instead of run when \`refusal()\` names why. */
-function guarded(call: (...args: unknown[]) => unknown): (...args: unknown[]) => unknown {
+function guarded(call: Call): Call {
 	return (...args) => {
 		const refused = refusal();
 		return refused === undefined ? call(...args) : Promise.reject(new Error(refused));
@@ -33,40 +33,55 @@ function ioFirst(): Promise<void> {
 	}
 }
 
-/** \`call\`, once \`io()\` lets it run, rejected instead of run when \`refusal()\` names why. */
-function guarded(call: (...args: unknown[]) => unknown): (...args: unknown[]) => unknown {
+/**
+ * \`call\`, made at once when it may run (its request awaits \`io()\`); when
+ * \`refusal()\` names why it may not, made once \`io()\` lets it if it may run
+ * then, and rejected instead otherwise.
+ */
+function guarded(call: Call): Call {
 	return (...args) =>
-		ioFirst().then(() => {
-			const refused = refusal();
-			return refused === undefined ? call(...args) : Promise.reject(new Error(refused));
-		});
+		refusal() === undefined
+			? call(...args)
+			: ioFirst().then(() => {
+					const refused = refusal();
+					return refused === undefined ? call(...args) : Promise.reject(new Error(refused));
+				});
 }
 `;
-const GUARD_SOURCE = `/** A frozen copy of one Resource's families, or one family's variants, each call guarded. */
-function guardedTree(tree: object): object {
+const GUARD_SOURCE = `/**
+ * A frozen copy of one Resource's families, or one family's variants: each call
+ * guarded, and made on what \`at\` reads of the \`current()\` client.
+ */
+function guardedTree(tree: object, at: (client: AvClient) => unknown): object {
 	const copy: Record<string, unknown> = Object.create(Object.getPrototypeOf(tree) as object | null);
 	for (const [key, value] of Object.entries(tree)) {
-		copy[key] = typeof value === "function" ? guarded(value as (...args: unknown[]) => unknown) : guardedTree(value as object);
+		const member = (client: AvClient): unknown => (at(client) as Readonly<Record<string, unknown>>)[key];
+		copy[key] =
+			typeof value === "function"
+				? guarded((...args) => (member(current()) as Call)(...args))
+				: guardedTree(value as object, member);
 	}
 	return Object.freeze(copy);
 }
 
 /**
- * The client with every call that sends a request guarded; \`tx\` builds
- * deferred operations and sends nothing, so it is kept as it is.
+ * A client shaped as \`template\`, every call that sends a request guarded and
+ * made on the \`current()\` client; \`tx\` builds deferred operations and sends
+ * nothing, so the template's is kept as it is.
  */
-function guardedClient(client: AvClient): AvClient {
+function guardedClient(template: AvClient): AvClient {
 	const copy: AvClient = Object.create(AvClient.prototype) as AvClient;
-	for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(client))) {
+	for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(template))) {
 		const value: unknown = descriptor.value;
+		const member = (client: AvClient): unknown => (client as unknown as Readonly<Record<string, unknown>>)[key];
 		Object.defineProperty(copy, key, {
 			...descriptor,
 			value:
 				key === "tx"
 					? value
 					: typeof value === "function"
-						? guarded(value as (...args: unknown[]) => unknown)
-						: guardedTree(value as object),
+						? guarded((...args) => (member(current()) as Call)(...args))
+						: guardedTree(value as object, member),
 		});
 	}
 	return copy;
@@ -100,6 +115,16 @@ function refusal(): string | undefined {
 	return onServer() ? SERVER_CALL : undefined;
 }
 
+type Call = (...args: unknown[]) => unknown;
+
+/** The one client every call is made on. */
+const CLIENT = new AvClient();
+
+/** The client a call made here and now is made on: the one client. */
+function current(): AvClient {
+	return CLIENT;
+}
+
 ${BROWSER_GUARD_SOURCE}
 ${GUARD_SOURCE}
 /**
@@ -107,7 +132,7 @@ ${GUARD_SOURCE}
  * on the server (while a Client Component renders there) rejects instead: on the
  * server, import \`avClient\` from \`@/aventara/server\` or \`@/aventara/universal\`.
  */
-export const avClient: AvClient = guardedClient(new AvClient());
+export const avClient: AvClient = guardedClient(CLIENT);
 
 /** The key a dehydrated value's tag is under: \`{ ${JSON.stringify(tagKey)}: <scalar>, ${JSON.stringify(valueKey)}: <its wire form> }\`. */
 const TAG = ${JSON.stringify(tagKey)};
@@ -177,9 +202,12 @@ function universalSource(style, accessVerbs) {
     return `${ENTRY_BANNER}
 
 import { io } from ${JSON.stringify(style.importFileExtension === "" ? "next/cache" : "next/cache.js")};
+import { cache } from "react";
 import { AvClient } from ${from(`./${GENERATED_DIRECTORY}/client`)};
 import type { AvFetch } from ${from(`./${GENERATED_DIRECTORY}/runtime/transport`)};
 
+import { avLazy as lazyCall } from ${from(`./${GENERATED_DIRECTORY}/runtime/operation-set`)};
+
 /** The key the server's in-process path is registered under, on globalThis, by ready() from @aventara/next. */
 const SERVER_PATH = Symbol.for(${JSON.stringify(UNIVERSAL_PATH_KEY)});
 
@@ -202,8 +230,9 @@ function refusal(): string | undefined {
 	return onServer() && serverPath() === undefined ? UNREGISTERED : undefined;
 }
 
-/** In the browser, the platform's fetch; on the server, the in-process path. */
-function universalFetch(...request: unknown[]): unknown {
+/** Once Next's \`io()\` lets it: in the browser, the platform's fetch; on the server, the in-process path. */
+async function universalFetch(...request: unknown[]): Promise<unknown> {
+	await ioFirst();
 	const reach = onServer() ? serverPath() : (globalThis as { readonly fetch?: AvFetch }).fetch;
 	if (reach === undefined) {
 		throw new TypeError(onServer() ? UNREGISTERED : "No fetch is available here.");
@@ -211,6 +240,51 @@ function universalFetch(...request: unknown[]): unknown {
 	return (reach as (...request: unknown[]) => unknown)(...request);
 }
 
+type Call = (...args: unknown[]) => unknown;
+
+/** The browser's one client, whose calls are grouped, and the shape \`avClient\` copies. */
+const BROWSER = new AvClient({ fetch: universalFetch as AvFetch });
+
+/**
+ * The client a call made here and now is made on: the browser's one; on the
+ * server, a client of the call's own with grouping off, so the call is sent
+ * alone, from the async context it was made in (the request's, or a scope
+ * nested in it), and shares no queue with any other call.
+ */
+function current(): AvClient {
+	return onServer() ? new AvClient({ fetch: universalFetch as AvFetch, grouping: false }) : BROWSER;
+}
+
+/** On the server, the calls each avLazy made in the request being rendered (React's \`cache\`). */
+const requestCalls = cache((): WeakMap<object, Promise<unknown>> => new WeakMap());
+
+/**
+ * Describe a call now, make it later: the tree's avLazy, which avClient.all
+ * accepts on either side. In the browser it makes the call once and keeps its
+ * answer. On the server it keeps one answer per request: inside a React
+ * request scope (a render), each request makes the call once, in its own
+ * context; where React keeps no request (a route handler, a Server Action),
+ * it keeps nothing, and each await makes the call again.
+ *
+ * @example const posts = avLazy(() => avClient.Post.find.many({}));
+ */
+export function avLazy<T>(run: () => PromiseLike<T>): Promise<T> {
+	const key = {};
+	return lazyCall(() => {
+		if (!onServer()) {
+			return run();
+		}
+		const calls = requestCalls();
+		const made = calls.get(key);
+		if (made !== undefined) {
+			return made as Promise<T>;
+		}
+		const call = Promise.resolve(run());
+		calls.set(key, call);
+		return call;
+	});
+}
+
 ${UNIVERSAL_GUARD_SOURCE}
 ${GUARD_SOURCE}
 /**
@@ -221,7 +295,7 @@ ${GUARD_SOURCE}
  * prefetched on the server hydrates in the browser: pass it through
  * \`avDehydrate\` (\`@aventara/next\`) and \`avHydrate\` (\`@/aventara/client\`).
  */
-export const avClient: AvClient = ${accessVerbs ? "withServerAccess(" : ""}guardedClient(new AvClient({ fetch: universalFetch as AvFetch }))${accessVerbs ? ")" : ""};
+export const avClient: AvClient = ${accessVerbs ? "withServerAccess(" : ""}guardedClient(BROWSER)${accessVerbs ? ")" : ""};
 ${accessVerbs ? SERVER_ACCESS_SOURCE : ""}`;
 }
 const UNIVERSAL_ACCESS_KEY = "aventara.next.universal.access";

package/dist/project/project-modules.loader.js

@@ -5,6 +5,7 @@ import { createJiti } from "jiti";
 import { AvBuildError } from "../build.error.js";
 const EXTENSIONS = [".js", ".ts", ".mjs", ".cjs", ".mts", ".cts"];
 const EXTENSIONS_AS_LISTED = [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"];
+const SERVER_MARKERS = { "server-only": {} };
 const CONFIG_EXPORTS = ["aventaraConfig", "default"];
 function projectFile(projectDirectory, module, layout) {
     const present = EXTENSIONS.map((extension) => `${module}${extension}`).filter((file) => statSync(path.join(projectDirectory, file), {
@@ -107,6 +108,7 @@ export async function loadProjectModules(projectDirectory, { configFile, adapter
         fsCache: false,
         interopDefault: false,
         nativeModules: ["@aventara/core"],
+        virtualModules: SERVER_MARKERS,
     });
     const project = await projectCore(jiti);
     const config = configOf(configFile, await evaluate(jiti, projectDirectory, configFile));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aventara/build",
-  "version": "1.0.0-rc.10",
+  "version": "1.0.0-rc.12",
   "license": "SEE LICENSE IN LICENSE",
   "description": "Compiles an Aventara application's Contracts at build time, for serverless and edge cold starts.",
   "type": "module",
@@ -16,18 +16,18 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@aventara/client": "1.0.0-rc.10",
+    "@aventara/client": "1.0.0-rc.12",
     "jiti": "2.7.0"
   },
   "peerDependencies": {
-    "@aventara/core": "1.0.0-rc.10",
+    "@aventara/core": "1.0.0-rc.12",
     "typescript": ">=5.7.0 <7"
   },
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
-    "@aventara/core": "1.0.0-rc.10",
+    "@aventara/core": "1.0.0-rc.12",
     "@types/node": "24.10.1",
     "typescript": "^5.9.2"
   },