@fougere/nuxt 0.1.0-alpha.0

package/src/runtime/server/utils/fougereApp.ts

@@ -0,0 +1,209 @@
+/**
+ * Fougere server bootstrap — single entry point for app lifecycle in Nuxt.
+ *
+ * Default path (zero-config): fougere.config.ts declares `db: 'sqlite'` and
+ * everything else; this module auto-resolves the storage handle, builds an
+ * ormFactory, runs auto-DDL from the entities, and boots the app.
+ *
+ * Escape hatch: `configureFougere({ db, ormFactory })` can be called from a
+ * Nitro plugin if the user wants a custom data layer (alternative driver,
+ * managed migrations, etc.).
+ */
+import { createApp, loadCascadedConfig, setModuleLoader, frondAliases, Logger } from '@fougere/core';
+import { createContainer } from '@fougere/container-fougere';
+import type { App, EntityOrm, FougereConfig, Transport } from '@fougere/core';
+import { applyCreate, applyUpdate, type SchemaLike } from '@fougere/schema';
+
+// ── Public types ─────────────────────────────────
+
+export interface FougereServerConfig {
+  /** Storage handle. Forwarded to the auth provider via AuthContext.db. */
+  db?: unknown;
+  /** Per-entity ORM factory. */
+  ormFactory?: (entity: SchemaLike, name: string) => EntityOrm;
+  /** Called after app is created. Use for migrations, seeding, etc. */
+  afterBoot?: (app: App) => void | Promise<void>;
+}
+
+// ── State ────────────────────────────────────────
+
+let _config: FougereServerConfig = {};
+let _appPromise: Promise<App> | null = null;
+
+// ── Public API ───────────────────────────────────
+
+/**
+ * Override the data layer — only needed if you don't want the convention-driven
+ * setup based on `config.db` in fougere.config.ts.
+ */
+export function configureFougere(config: FougereServerConfig) {
+  _config = config;
+  _appPromise = null;
+}
+
+/** Get the booted Fougere app. Lazy — boots on first call, then caches. */
+export function useFougereApp(): Promise<App> {
+  if (!_appPromise) {
+    _appPromise = boot();
+  }
+  return _appPromise;
+}
+
+// ── Boot ─────────────────────────────────────────
+
+async function boot(): Promise<App> {
+  const bootStart = performance.now();
+  const log = new Logger('boot', { level: 'debug' });
+
+  log.info('booting (Nuxt/Nitro)');
+
+  const { createJiti } = await import('jiti');
+  // Nitro serves from a bundle, but the scan still reads frond sources from disk — so the
+  // named form a frond uses for its neighbour has to resolve here too.
+  const jiti = createJiti(import.meta.url, {
+    interopDefault: true,
+    alias: await frondAliases(process.env.FOUGERE_ROOT ?? process.cwd()),
+  });
+  setModuleLoader((filePath) => jiti.import(filePath) as Promise<Record<string, unknown>>);
+
+  // Config cascades along the workspace→app frontier: the workspace root (via
+  // FOUGERE_ROOT, where `remotes`/shared db live) is the base, the app (cwd)
+  // overrides. Same boundary the fronds cascade along. No `root` → both equal.
+  const configRoot = process.cwd();
+  const root = process.env.FOUGERE_ROOT ?? configRoot;
+  const fileConfig: FougereConfig = await loadCascadedConfig(root, configRoot);
+
+  // Auto-resolve the data layer from config.db when the user didn't provide a
+  // custom one via configureFougere. The resolution itself lives in @fougere/runtime
+  // — this host must not know which storage package backs `db:`.
+  let db = _config.db;
+  let ormFactory = _config.ormFactory;
+  let migrateSchema: ((app: never) => Promise<void> | void) | undefined;
+  if (!ormFactory) {
+    const { resolveStorage } = await import('@fougere/runtime');
+    const storage = resolveStorage(fileConfig.db as never);
+    if (storage.ormFactory) {
+      log.debug('auto-resolving storage from config.db');
+      db = storage.db;
+      ormFactory = storage.ormFactory;
+      migrateSchema = storage.afterBoot as never;
+    } else {
+      log.debug('no db declared — falling back to in-memory ORM');
+      ormFactory = createMemoryOrm;
+    }
+  }
+
+  // Layer-2 wiring: `remotes: { catalog: 'http://...' }` in fougere.config.ts
+  // is all the user writes — the default transport comes from here.
+  let remoteTransport: ((url: string) => Transport) | undefined;
+  if (Object.keys(fileConfig.remotes ?? {}).length > 0) {
+    log.debug(`remotes declared (${Object.keys(fileConfig.remotes!).join(', ')}) — wiring HTTP transport`);
+    const { createHttpTransport } = await import('@fougere/transport-http');
+    remoteTransport = (url) => createHttpTransport(url);
+  }
+
+  const app = await createApp({
+    root,
+    createContainer,
+    ormFactory,
+    db,
+    auth: fileConfig.auth,
+    remotes: fileConfig.remotes,
+    remoteTransport,
+  });
+
+  // Bring the schema up to date — creates missing tables and adds columns an
+  // entity gained. Auth entities travel with the app, no synthetic frond needed.
+  if (migrateSchema) {
+    log.debug('migrating schema from entities');
+    await migrateSchema(app as never);
+  }
+
+  if (_config.afterBoot) {
+    log.debug('running afterBoot');
+    await _config.afterBoot(app);
+    log.info('afterBoot done');
+  }
+
+  const ms = (performance.now() - bootStart).toFixed(0);
+  log.info(`ready in ${ms}ms — ${app.fronds.length} frond(s)${app.auth ? ` + auth (${app.auth.basePath})` : ''}`);
+
+  return app;
+}
+
+// ── Fallback ORM ─────────────────────────────────
+
+/**
+ * The store an app with no `db` runs on.
+ *
+ * It used to ignore both its arguments — `(_entity, _name)` — so it forced the field
+ * name `id`, minted a uuid whatever the entity declared, and realized none of the
+ * lifecycle rules: `auto()` stamped nothing, a declared default stayed absent. The
+ * same page therefore behaved one way here and another way on SQLite.
+ *
+ * It reads the axes now, through the one realization every storage shares.
+ */
+export function createMemoryOrm(entity: SchemaLike, name: string): EntityOrm {
+  const fields = entity.getFields();
+  const pk = Object.entries(fields).find(([, field]) => field.role?.primary)?.[0] ?? 'id';
+  const store = new Map<string, Record<string, unknown>>();
+  // `EntityOrm.findById(id: string)` — but a key can hold a number, and a Map keyed on
+  // `1` does not answer `'1'`. SQL never had the question; here the divergence was
+  // silent and only on this storage.
+  const keyOf = (value: unknown) => String(value);
+  const matches = (row: Record<string, unknown>, criteria: Record<string, unknown>) =>
+    Object.entries(criteria).every(([key, value]) => Object.is(row[key], value));
+  return {
+    client: store,
+    async list(options?: any) {
+      let items = [...store.values()];
+      if (options?.where) items = items.filter((row) => matches(row, options.where));
+      const limit = options?.limit;
+      const offset = options?.page && limit ? (options.page - 1) * limit : options?.offset ?? 0;
+      if (offset > 0) items = items.slice(offset);
+      const hasMore = limit ? items.length > limit : false;
+      if (limit) items = items.slice(0, limit);
+      const result = items as any;
+      result.hasMore = hasMore;
+      result.endCursor = items.length > 0 ? String((items[items.length - 1] as any)[pk] ?? '') : undefined;
+      if (options?.count) result.total = store.size;
+      return result;
+    },
+    async findById(id: string) { return store.get(keyOf(id)); },
+    async findBy(criteria: Record<string, unknown>) {
+      return [...store.values()].find((row) => matches(row, criteria));
+    },
+    async findAllBy(criteria: Record<string, unknown>) {
+      return [...store.values()].filter((row) => matches(row, criteria));
+    },
+    async create(input: Partial<Record<string, unknown>>) {
+      const record = applyCreate(fields, input);
+      const id = record[pk] as string | undefined;
+      // `primary(text())` declares no generator, so nothing fills the hole and the
+      // caller has to. Keying on `undefined` would let the second create overwrite the
+      // first, in silence — the old version hid this by inventing an `id` field the
+      // entity never declared.
+      if (id === undefined) {
+        throw new Error(`${name}.create: '${pk}' is the primary key and nothing supplied it — this entity declares no generator for it.`);
+      }
+      // A create is not an upsert. `Map.set` overwrites, so a second create under the
+      // same key answered "created" while destroying the previous row — SQL answers a
+      // constraint violation, and a store that loses data silently is worse than one
+      // that fails.
+      if (store.has(keyOf(id))) {
+        throw new Error(`${name}.create: '${pk}' ${JSON.stringify(id)} already exists.`);
+      }
+      store.set(keyOf(id), record);
+      return record;
+    },
+    async update(id: string, input: Partial<Record<string, unknown>>) {
+      const existing = store.get(keyOf(id));
+      if (!existing) throw new Error(`Not found: ${id}`);
+      const updated = { ...existing, ...applyUpdate(fields, input), [pk]: existing[pk] };
+      store.set(keyOf(id), updated);
+      return updated;
+    },
+    async delete(id: string) { return store.delete(keyOf(id)); },
+    output(_schema: SchemaLike) { return this; },
+  };
+}

package/src/runtime/server/utils/fougereAuth.ts

@@ -0,0 +1,20 @@
+/**
+ * Auth accessor — reads the AuthRuntime that the core mounted on the app.
+ *
+ * Auth is no longer a separate singleton: it lives on `app.auth`, built once
+ * during boot from the `auth` field of fougere.config.ts. This accessor is a
+ * thin async helper for server code (middleware, routes, /api/me).
+ */
+import type { AuthRuntime } from '@fougere/core';
+import { useFougereApp } from './fougereApp';
+
+/** Get the auth runtime resolved at boot. Throws if no `auth` was declared in fougere.config.ts. */
+export async function useFougereAuth(): Promise<AuthRuntime> {
+  const app = await useFougereApp();
+  if (!app.auth) {
+    throw new Error(
+      'Auth not configured — declare `auth: { provider, ... }` in fougere.config.ts.',
+    );
+  }
+  return app.auth;
+}

package/src/runtime/server/utils/invoke.ts

@@ -0,0 +1,42 @@
+/**
+ * The server dual of the couple — same designation (class + verb), same
+ * return, same errors. Fabricates the call value and hands it to the app
+ * runner: local façade → direct in-memory execution, frond in `remotes`
+ * → JSON-RPC on the wire. The caller never knows which.
+ *
+ * In request context the current session rides along (event.context →
+ * invocation.state); outside a request, state is empty or explicit.
+ */
+import { useEvent } from 'nitropack/runtime';
+import {
+  createAppRunner,
+  callValueOf,
+  type FrondCall,
+  type InvocationContext,
+} from '@fougere/core';
+import { useFougereApp } from './fougereApp';
+
+type EntityClass = { name: string };
+type CallInput = Partial<InvocationContext>;
+
+export async function invoke<T = unknown>(entity: EntityClass, op: string, input?: CallInput): Promise<T>;
+export async function invoke<T = unknown>(call: FrondCall, input?: CallInput): Promise<T>;
+export async function invoke<T = unknown>(
+  target: EntityClass | FrondCall,
+  opOrInput?: string | CallInput,
+  input?: CallInput,
+): Promise<T> {
+  const given = typeof opOrInput === 'string' ? input : opOrInput;
+  const { call, invocation } = callValueOf(target, opOrInput, input);
+  const state = given?.state ?? requestState();
+  const app = await useFougereApp();
+  return (await createAppRunner(app)(call, { ...invocation, state })) as T;
+}
+
+function requestState(): Record<string, unknown> {
+  try {
+    return (useEvent()?.context ?? {}) as Record<string, unknown>;
+  } catch {
+    return {};
+  }
+}

package/src/runtime/session/view.ts

@@ -0,0 +1,20 @@
+/**
+ * The session view — the one place that turns the server-resolved
+ * request context (filled by the auth middleware) into what the client
+ * is allowed to see. One resolution, three readers: the page by
+ * hydration, the refresh route over the wire, handlers by invocation.
+ *
+ * The app-declared context (viewer enrichment) will attach here when
+ * a real case lands — this function is the seam.
+ */
+
+export interface SessionView {
+  user: Record<string, unknown> | null;
+}
+
+export function sessionViewOf(context: Record<string, unknown>): SessionView {
+  const raw = context.user as Record<string, unknown> | undefined;
+  if (!raw) return { user: null };
+  const { passwordHash: _passwordHash, ...user } = raw;
+  return { user };
+}