@fougere/nuxt 0.4.0-alpha.0 → 0.5.0-alpha.0

package/src/module.ts

@@ -17,7 +17,7 @@ import {
 import type { Nuxt } from '@nuxt/schema';
 import { orderSeeds } from '@fougere/core';
 import {
-  scanProject, emitScan, frondAliases, frondPackage, watchPathsOf, resolveConventions, type Conventions,
+  scanProject, emitStatement, frondAliases, frondPackage, watchPathsOf, resolveConventions, type Conventions,
   setModuleLoader, loadCascadedConfig,
 } from '@fougere/core/node';
 import { declaresStorage } from '@fougere/defaults';
@@ -35,6 +35,40 @@ export interface FougereModuleOptions {
    * fronds are shared at the root. Config and `.fougere` stay app-local.
    */
   root?: string;
+
+  /**
+   * One key per EXTENSION, and the key is the package suffix AND the export name —
+   * `calls` is `import { calls } from '@fougere/calls'`. So the module holds no table to
+   * keep in step with the packages, the same rule the scan applies to `@fronds/<name>`.
+   *
+   * An extension is a FUNCTION and this module writes a FILE, so a project cannot pass one
+   * here: it names one, and the options travel beside it as data.
+   *
+   * The keys are declared rather than left open on purpose. An open record would derive
+   * everything and accept `callz: {}` in silence — the failure this repo already records
+   * for `adapters:`, which "fails OPEN, giving neither completion nor a guard". The price
+   * is that a new extension package adds a key here.
+   */
+  /** `@fougere/observability` — a span per operation, the four signals, OTLP. */
+  observability?: Record<string, unknown> | false;
+  /** `@fougere/calls` — the dev panel: a bounded log of what this process dispatched. */
+  calls?: Record<string, unknown> | false;
+}
+
+/**
+ * The extension keys, in the order they are mounted.
+ *
+ * A list and not the options object's own keys: the ORDER is ours, not the project's.
+ * `observability` installs the middleware that opens the span every log line written
+ * inside a call will carry — mounted the other way round, the lines leave uncorrelated.
+ */
+const EXTENSION_KEYS = ['observability', 'calls'] as const;
+
+/** What the project asked for, in mount order. `false` is how a key is turned off. */
+export function extensionsOf(options: FougereModuleOptions): { key: string; options: unknown }[] {
+  return EXTENSION_KEYS
+    .filter((key) => options[key] !== undefined && options[key] !== false)
+    .map((key) => ({ key, options: options[key] }));
 }
 
 
@@ -54,7 +88,7 @@ const module = defineNuxtModule<FougereModuleOptions>({
   async setup(options: FougereModuleOptions, nuxt: Nuxt) {
     const { resolve: resolveModule } = createResolver(import.meta.url);
     const runtimeResolve = (...path: string[]) =>
-      resolveModule('../src/runtime', ...path);
+      resolveModule('./runtime', ...path);
     const rootDir = nuxt.options.rootDir;
     // Fronds may live at the workspace root (app under apps/*); config/.fougere stay app-local.
     const scanRoot = options.root ? resolve(rootDir, options.root) : rootDir;
@@ -242,29 +276,43 @@ const module = defineNuxtModule<FougereModuleOptions>({
       });
     }
 
-    // ── 6. The scan, written down (virtual — lives in .nuxt/) ───
+    // ── 6. What this app hosts ───
     //
-    // The module ALREADY scanned, above. Without this the generated plugin scanned a
-    // second time, at runtime — which is right on a server and impossible on a Worker:
-    // measured on workerd, `readdir` throws through unenv's shim and the app boots with
-    // ZERO fronds. Every page renders, every door answers NOT_FOUND, and only the scan
-    // diagnostics say why. One scan, one value, handed to the boot.
+    // A `fronds.ts` beside `fougere.config.ts` is the app STATING it — the same shape
+    // `configureFougere({ fronds })` gives every other host, made where the author can
+    // make it. The scan still runs at build and stays a CHECK: its diagnostics reach the
+    // console, and it becomes no module.
     //
-    // `emitScan` writes imports relative to where the module SITS, so the destination is
-    // settled before the source is produced — `dst` is that path.
-    const scanTpl = addTemplate({
-      filename: 'fougere-scan.ts',
+    // Nothing is generated, because a generated module was imported by ABSOLUTE path,
+    // which a bundler sees as `file://` and therefore external. Externalized, Node read
+    // the frond's `.ts` itself — stripping types but resolving `../entities/Post.js`
+    // literally, a file that is not on disk. Measured on demos/nuxt-blog in-process:
+    // 500 on every call in `nuxt dev`, 200 once the statement is the only source.
+    // A codegen inside one repo also had nothing to carry: `fougere sync` writes classes
+    // because its source is ANOTHER repo, and here the author can just import.
+    const stated = ['fronds.ts', 'fronds.mts', 'fronds.js', 'fronds.mjs']
+      .map((f) => resolve(scanRoot, f)).find((f) => existsSync(f));
+
+    // No statement of its own: the build writes the one the scan implies, so the runtime
+    // never reaches `scanProject`. That fallback works — it has a disk under Nuxt — but it
+    // loads `typescript` into a production boot, which is the whole of what a build is for.
+    // What is written is the STATEMENT (imports + `frond()`), never the scan result.
+    // `.ts`, and it is not cosmetic: the file spells its imports the way TypeScript sources
+    // do (`Post.js` for `Post.ts`), and Nitro externalizes a `.mjs` it can hand to Node —
+    // which then resolves `@fronds/*` against a package that does not exist, since an alias
+    // is a bundler's. Measured both ways, in-process: `.mjs` answers 500, `.ts` answers.
+    const statedPath = stated ?? addTemplate({
+      filename: 'fougere-fronds.ts',
       write: true,
-      getContents: ({ nuxt: n }) =>
-        emitScan(scan, { outFile: resolve(n!.options.buildDir, 'fougere-scan.ts') }),
-    });
+      getContents: () => emitStatement(scan),
+    }).dst;
 
     // ── 6b. Boot plugin (virtual — lives in .nuxt/) ───
     const allSeeds = orderSeeds(fronds);
     const bootTpl = addTemplate({
       filename: 'fougere-boot.ts',
       write: true,
-      getContents: () => generateBootPlugin(config, allSeeds, runtimeResolve('server/utils/boot'), scanTpl.dst),
+      getContents: () => generateBootPlugin(config, allSeeds, runtimeResolve('server/utils/boot'), extensionsOf(options), statedPath),
     });
     addServerPlugin(bootTpl.dst);
 
@@ -324,8 +372,10 @@ export function generateBootPlugin(
   config: FougereConfig,
   seeds: SeedEntry[],
   fougereAppPath: string,
-  /** The module `emitScan` wrote. Absent only in the tests that predate it. */
-  scanPath?: string,
+  /** What `fougere:` named, in mount order. Empty is the whole of "changed nothing". */
+  extensions: { key: string; options: unknown }[] = [],
+  /** The app's own `fronds.ts`, when it states what it hosts instead of being scanned. */
+  statedPath?: string,
 ): string {
   const lines: string[] = [];
   lines.push(`// Auto-generated by @fougere/nuxt — do not edit`);
@@ -334,7 +384,12 @@ export function generateBootPlugin(
   lines.push(`import { configureFougere } from '${fougereAppPath}';`);
   // A STATIC import, because that is the one thing a bundler needs spelled out — and the
   // whole point is that nothing reads a directory once this file is built.
-  if (scanPath) lines.push(`import { scan } from '${scanPath}';`);
+  // The extension is DROPPED, and that is what decides who reads the file: an extensionless
+  // specifier cannot be resolved by Node, so the bundler resolves it — and only a bundler
+  // applies the `@fronds/*` aliases the statement's own imports are written with. Left in
+  // place, the path resolves natively, Node reads the frond's `.ts` and every call answers
+  // 500. Measured both ways on demos/nuxt-blog, in-process.
+  if (statedPath) lines.push(`import fronds from '${statedPath.replace(/\.(m?)[jt]sx?$/, '')}';`);
 
   const db = config.db ?? 'sqlite';
   const sources = (config as { sources?: unknown }).sources;
@@ -349,7 +404,10 @@ export function generateBootPlugin(
   if (!declaresStorage(db as Parameters<typeof declaresStorage>[0])) {
     lines.push(``);
     lines.push(`export default defineNitroPlugin(() => {`);
-    if (scanPath) lines.push(`  configureFougere({ scan, config: ${JSON.stringify(carried(config))} });`);
+    // Always configure, even with nothing to host: `hostedBy` is where the absence is
+    // answered, by name and with both keys. Skipping the call boots a silent app instead.
+    const states = statedPath ? 'fronds, ' : '';
+    lines.push(`  configureFougere({ ${states}config: ${JSON.stringify(carried(config))} });`);
     lines.push(`});`);
     return lines.join('\n') + '\n';
   }
@@ -359,6 +417,12 @@ export function generateBootPlugin(
   lines.push(`import { resolveStorage } from '@fougere/defaults';`);
   // After the early return above: an app that declares no storage generates no imports.
   lines.push(`import { migrating${seeds.length ? ', runSeeds' : ''} } from '@fougere/core';`);
+  // One import per key the project named. The key IS the export and the package suffix, so
+  // a missing package is a build error naming the package — not a boot that silently lacks
+  // the panel someone asked for.
+  for (const { key } of extensions) {
+    lines.push(`import { ${key} } from '@fougere/${key}';`);
+  }
   lines.push(``);
 
   // Seed imports
@@ -369,14 +433,14 @@ export function generateBootPlugin(
 
   // Wrap all init in the plugin callback to avoid top-level native calls
   lines.push(`export default defineNitroPlugin(async () => {`);
-  // The SCAN first, and on its own line: it names no engine, so nothing below can stop it
-  // from being stated. Measured on workerd — `resolveStorage` threw on a native driver,
+  // What it HOSTS first, and on its own line: it names no engine, so nothing below can stop
+  // it from being stated. Measured on workerd — `resolveStorage` threw on a native driver,
   // Nitro swallowed the plugin whole, and the app came up with zero fronds and not a word.
-  // Two unrelated facts had been sharing one failure.
-  // The scan AND what the config says about topology — both read at build, both stated
-  // here rather than re-derived. `remotes` is the whole reason a consumer boots at all:
-  // without it the app hosts nothing and reaches nothing, and its pages render empty.
-  if (scanPath) lines.push(`  configureFougere({ scan, config: ${JSON.stringify(carried(config))} });`);
+  // Two unrelated facts had been sharing one failure. `remotes` rides along for the same
+  // reason: it is the whole of why a consumer that hosts nothing boots at all.
+  const states = statedPath ? 'fronds, ' : '';
+  lines.push(`  configureFougere({ ${states}config: ${JSON.stringify(carried(config))} });`);
+  lines.push(``);
   lines.push(`  try {`);
   // Pass `db` through unchanged — resolveStorage (@fougere/defaults → setupSqlite)
   // is the one place that defaults an absent path, so both call sites (this
@@ -387,7 +451,7 @@ export function generateBootPlugin(
   lines.push(`    const storage = resolveStorage(${JSON.stringify(db)}${sourcesArg});`);
   lines.push(``);
   lines.push(`    configureFougere({`);
-  if (scanPath) lines.push(`      scan,`);
+  if (statedPath) lines.push(`      fronds,`);
   lines.push(`      config: ${JSON.stringify(carried(config))},`);
   lines.push(`      db: storage.db,`);
   lines.push(`      ormFactory: storage.ormFactory,`);
@@ -415,6 +479,12 @@ export function generateBootPlugin(
     lines.push(`        ], (message) => console.log('[fougere:seed]' + message)) },`);
   }
 
+  // After the framework's own members, never before: tables, then rows, then what the host
+  // adds. A key named 'seeds' would REPLACE core's, which is the delta rule of AppLifecycle.
+  for (const { key, options } of extensions) {
+    lines.push(`        ${key}(${JSON.stringify(options ?? {})}),`);
+  }
+
   lines.push(`      ],`);
   lines.push(`    });`);
   // A storage that could not be opened is REPORTED, never swallowed. Nitro takes a

package/src/runtime/composables/useFougereData.ts

@@ -63,7 +63,17 @@ export async function useQuery<T = Record<string, unknown>>(
   const total = computed(() => pageOf(data.value).total);
   const hasMore = computed(() => pageOf(data.value).hasMore);
 
-  return { data: data as Ref<T | null>, items, total, hasMore, loading: pending, error, refresh };
+  return {
+    data: data as Ref<T | null>,
+    items,
+    total,
+    hasMore,
+    loading: pending,
+    error,
+    // Nuxt does not export AsyncDataExecuteOptions, so the inferred signature cannot
+    // be named from outside; callers pass nothing.
+    refresh: refresh as () => Promise<void>,
+  };
 }
 
 export function useCommand<T = unknown>(entity: EntityClass, op: string) {

package/src/runtime/server/auth/routes/auth/[...].ts

@@ -1,4 +1,4 @@
-import { defineEventHandler } from 'h3';
+import { defineEventHandler, toWebRequest, sendWebResponse } from 'h3';
 import { useFougereAuth } from '@fougere/app';
 
 export default defineEventHandler(async (event) => {

package/src/runtime/server/routes/call.post.ts

@@ -9,6 +9,7 @@
  */
 import { defineEventHandler } from 'h3';
 import { serveRpc, rpcParseError, useFougereApp } from '@fougere/app';
+import { MAX_BODY_BYTES } from '@fougere/core';
 
 type NodeReq = {
   body?: unknown;
@@ -22,7 +23,6 @@ type WebReq = {
   json?: () => Promise<unknown>;
 };
 
-const MAX_BODY_BYTES = 1024 * 1024;
 
 function payloadTooLarge(): Error & { statusCode: number; statusMessage: string } {
   return Object.assign(new Error('Payload too large'), { statusCode: 413, statusMessage: 'Payload too large' });

package/src/shims.d.ts

@@ -0,0 +1,7 @@
+// Nuxt's virtual barrel has no file to resolve to; the shim says where its types are,
+// never what they say. (`nitropack/runtime` is redirected by tsconfig paths instead:
+// it DOES resolve, and an ambient declaration cannot override a resolution.)
+declare module '#imports' {
+  // Nuxt's virtual barrel, resolved when the app builds.
+  export * from 'nuxt/app';
+}