rimecms 0.30.3 → 0.31.0

package/dist/core/dev/generate/runtime/index.server.d.ts

@@ -4,21 +4,37 @@ export type RuntimeRegistryEntry = {
 };
 export type RuntimeRegistry = Map<string, RuntimeRegistryEntry>;
 /**
- * Builds the `$rime/<name>` → { browser file, server file } lookup table.
+ * Finds an installed package's root by walking up from `fromDir`, checking each ancestor's
+ * `node_modules/<pkgName>` directly for a `package.json` — the pre-`exports` Node resolution
+ * algorithm, pure directory existence, no `exports`-conditions matching involved at all.
  *
- * @example rime's own field, installed as a dependency in some app
- * // /my-app/node_modules/rimecms/dist/fields/relation/module.ts + module.server.ts
- * // → registry.get('fields/relation') → { client: '.../module.ts', server: '.../module.server.ts' }
- * // → import { x } from '$rime/fields/relation'   // resolves
- *
- * @example that same app's own custom field
- * // /my-app/src/lib/fields/geocode/module.ts + module.server.ts
- * // → registry.get('fields/geocode') → { client: '.../module.ts', server: '.../module.server.ts' }
- * // → import { x } from '$rime/fields/geocode'    // resolves, same mechanism, zero extra setup
+ * Needed in place of `require.resolve`/`import.meta.resolve`: both gate on a package's own
+ * `exports` map matching some condition set (`"require"`/`"default"` for the former, whatever
+ * conditions the resolving runtime declares for the latter), and a package that only exposes
+ * conditions neither uses — confirmed in practice with rime's own `"."` export, `types`/
+ * `svelte`/`import` only, no `"require"`/`"default"` fallback — fails to resolve even its own
+ * main entry through either API. This sidesteps that entirely: `node_modules/<pkgName>` is a
+ * real directory (or, under pnpm, a real symlink `fs.existsSync` follows transparently)
+ * regardless of what that package's `exports` map declares.
+ */
+export declare function findInstalledPackageRoot(pkgName: string, fromDir: string): string;
+/**
+ * Direct, single-lookup check for one `<root>/<name>/module(.server)?.ts|js` pair — no
+ * directory walk, just the two `fs.existsSync`-style checks `findModuleFile` already does.
+ * Used by the Vite plugin's `resolveId`/`load` for on-demand resolution of a `$rime/modules`
+ * self-reference; `scanModulePairs` below (a real walk) stays reserved for the barrel (which
+ * needs every pair at once) and type generation.
+ */
+export declare function findModulePair(root: string, name: string): RuntimeRegistryEntry | null;
+/**
+ * Recursively finds every `module`/`module.server` folder under `root`, registered under the
+ * containing folder's path relative to `root` — e.g. `fields/relation/module.ts` under a
+ * `src/lib`-rooted scan registers as `fields/relation`. Used by the `$rime/modules` barrel
+ * (live, dev-mode only) and by `generate-manifest` (once, at prepack, scanning `dist/`).
  *
- * @example nothing on disk for that name
- * // no folder anywhere has both typo/module.ts and typo/module.server.ts
- * // → registry.get('typo') → undefined
- * // → import { x } from '$rime/typo'               // fails: "cannot resolve module"
+ * Either file alone is enough to register (single-sided is legitimate — a server-only piece,
+ * e.g. a collection's hooks, never needs a hand-written client stub; the missing side is just
+ * an empty string here, same convention `findModulePair` above uses). `rime.generated/` is
+ * skipped since it's sanitize's own output, unrelated to this.
  */
-export declare function buildRuntimeRegistry(): RuntimeRegistry;
+export declare function scanModulePairs(root: string): RuntimeRegistry;

package/dist/core/dev/generate/runtime/index.server.js

@@ -1,23 +1,33 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { isInstalledDependency, OUTPUT_DIR } from '../../constants.js';
+import { OUTPUT_DIR } from '../../constants.js';
 /**
- * Walks up from `startDir` to the nearest ancestor containing a `package.json`, then returns
- * its `dist/` — self-correcting regardless of how deeply nested this file is (unlike counting
- * a fixed number of `..` segments, which would silently point at the wrong directory, not
- * error, the moment this file's own location changes).
+ * Finds an installed package's root by walking up from `fromDir`, checking each ancestor's
+ * `node_modules/<pkgName>` directly for a `package.json` — the pre-`exports` Node resolution
+ * algorithm, pure directory existence, no `exports`-conditions matching involved at all.
+ *
+ * Needed in place of `require.resolve`/`import.meta.resolve`: both gate on a package's own
+ * `exports` map matching some condition set (`"require"`/`"default"` for the former, whatever
+ * conditions the resolving runtime declares for the latter), and a package that only exposes
+ * conditions neither uses — confirmed in practice with rime's own `"."` export, `types`/
+ * `svelte`/`import` only, no `"require"`/`"default"` fallback — fails to resolve even its own
+ * main entry through either API. This sidesteps that entirely: `node_modules/<pkgName>` is a
+ * real directory (or, under pnpm, a real symlink `fs.existsSync` follows transparently)
+ * regardless of what that package's `exports` map declares.
  */
-function findDistRoot(startDir) {
-    let dir = startDir;
-    while (!fs.existsSync(path.join(dir, 'package.json'))) {
+export function findInstalledPackageRoot(pkgName, fromDir) {
+    let dir = fromDir;
+    while (true) {
+        const candidate = path.join(dir, 'node_modules', pkgName);
+        if (fs.existsSync(path.join(candidate, 'package.json'))) {
+            return candidate;
+        }
         const parent = path.dirname(dir);
         if (parent === dir) {
-            throw new Error(`$rime: could not locate rimecms's package root above ${startDir}`);
+            throw new Error(`$rime/modules: could not find installed package '${pkgName}' above ${fromDir}`);
         }
         dir = parent;
     }
-    return path.join(dir, 'dist');
 }
 /** `module.ts` when scanning TS source, `module.js` when scanning a built `dist/`. */
 function findModuleFile(dir, baseName) {
@@ -29,16 +39,30 @@ function findModuleFile(dir, baseName) {
     return null;
 }
 /**
- * Recursively finds every `module`/`module.server` pair under `root`, registered under the
- * containing folder's path relative to `root` — `$rime/<key>` mirrors the real path, e.g.
- * `fields/relation/module.ts` under a `lib`-rooted scan registers as `fields/relation`.
+ * Direct, single-lookup check for one `<root>/<name>/module(.server)?.ts|js` pair — no
+ * directory walk, just the two `fs.existsSync`-style checks `findModuleFile` already does.
+ * Used by the Vite plugin's `resolveId`/`load` for on-demand resolution of a `$rime/modules`
+ * self-reference; `scanModulePairs` below (a real walk) stays reserved for the barrel (which
+ * needs every pair at once) and type generation.
+ */
+export function findModulePair(root, name) {
+    const dir = path.join(root, name);
+    const client = findModuleFile(dir, 'module');
+    const server = findModuleFile(dir, 'module.server');
+    return client || server ? { client: client ?? '', server: server ?? '' } : null;
+}
+/**
+ * Recursively finds every `module`/`module.server` folder under `root`, registered under the
+ * containing folder's path relative to `root` — e.g. `fields/relation/module.ts` under a
+ * `src/lib`-rooted scan registers as `fields/relation`. Used by the `$rime/modules` barrel
+ * (live, dev-mode only) and by `generate-manifest` (once, at prepack, scanning `dist/`).
  *
- * Both files are required to register a `$rime/<key>` entry: this pair only exists for a field
- * whose hook needs different server/client behavior (relation, link) — a field with nothing to
- * split just overrides `generateType()` on its builder directly and never needs either file.
- * `+rime.generated/` is skipped since it's sanitize's own output, unrelated to this.
+ * Either file alone is enough to register (single-sided is legitimate — a server-only piece,
+ * e.g. a collection's hooks, never needs a hand-written client stub; the missing side is just
+ * an empty string here, same convention `findModulePair` above uses). `rime.generated/` is
+ * skipped since it's sanitize's own output, unrelated to this.
  */
-function scanModulePairs(root) {
+export function scanModulePairs(root) {
     const registry = new Map();
     if (!fs.existsSync(root))
         return registry;
@@ -49,9 +73,9 @@ function scanModulePairs(root) {
             const fullPath = path.join(dir, entry.name);
             const client = findModuleFile(fullPath, 'module');
             const server = findModuleFile(fullPath, 'module.server');
-            if (client && server) {
+            if (client || server) {
                 const key = path.relative(root, fullPath).split(path.sep).join('/');
-                registry.set(key, { client, server });
+                registry.set(key, { client: client ?? '', server: server ?? '' });
             }
             walk(fullPath);
         }
@@ -59,35 +83,3 @@ function scanModulePairs(root) {
     walk(root);
     return registry;
 }
-/**
- * Builds the `$rime/<name>` → { browser file, server file } lookup table.
- *
- * @example rime's own field, installed as a dependency in some app
- * // /my-app/node_modules/rimecms/dist/fields/relation/module.ts + module.server.ts
- * // → registry.get('fields/relation') → { client: '.../module.ts', server: '.../module.server.ts' }
- * // → import { x } from '$rime/fields/relation'   // resolves
- *
- * @example that same app's own custom field
- * // /my-app/src/lib/fields/geocode/module.ts + module.server.ts
- * // → registry.get('fields/geocode') → { client: '.../module.ts', server: '.../module.server.ts' }
- * // → import { x } from '$rime/fields/geocode'    // resolves, same mechanism, zero extra setup
- *
- * @example nothing on disk for that name
- * // no folder anywhere has both typo/module.ts and typo/module.server.ts
- * // → registry.get('typo') → undefined
- * // → import { x } from '$rime/typo'               // fails: "cannot resolve module"
- */
-export function buildRuntimeRegistry() {
-    const registry = new Map();
-    if (isInstalledDependency(import.meta.url)) {
-        const nativeLibDir = findDistRoot(path.dirname(fileURLToPath(import.meta.url)));
-        for (const [key, entry] of scanModulePairs(nativeLibDir)) {
-            registry.set(key, entry);
-        }
-    }
-    const consumerLibDir = path.resolve(process.cwd(), 'src/lib');
-    for (const [key, entry] of scanModulePairs(consumerLibDir)) {
-        registry.set(key, entry);
-    }
-    return registry;
-}

package/dist/core/dev/generate/runtime/parse-exports.server.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Top-level named + default export identifiers of a module — used by the Vite plugin's
+ * `exportFrom()` to stub out a side of a `$rime/<name>` pair that wasn't authored (e.g. a
+ * collection's server-only hook, requested by a client build), matching the real side's
+ * export names so ESM's static named-export binding doesn't throw at link time.
+ */
+export declare function parseExportNames(filePath: string): string[];

package/dist/core/dev/generate/runtime/parse-exports.server.js

@@ -0,0 +1,40 @@
+import { babelParse } from 'ast-kit';
+import * as t from '@babel/types';
+import fs from 'node:fs';
+/**
+ * Top-level named + default export identifiers of a module — used by the Vite plugin's
+ * `exportFrom()` to stub out a side of a `$rime/<name>` pair that wasn't authored (e.g. a
+ * collection's server-only hook, requested by a client build), matching the real side's
+ * export names so ESM's static named-export binding doesn't throw at link time.
+ */
+export function parseExportNames(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const ast = babelParse(content, 'ts', { sourceType: 'module', attachComment: false });
+    const names = [];
+    for (const node of ast.body) {
+        if (t.isExportNamedDeclaration(node)) {
+            if (node.declaration) {
+                if (t.isVariableDeclaration(node.declaration)) {
+                    for (const decl of node.declaration.declarations) {
+                        if (t.isIdentifier(decl.id))
+                            names.push(decl.id.name);
+                    }
+                }
+                else if ('id' in node.declaration &&
+                    node.declaration.id &&
+                    t.isIdentifier(node.declaration.id)) {
+                    names.push(node.declaration.id.name);
+                }
+            }
+            for (const spec of node.specifiers) {
+                if (t.isExportSpecifier(spec) && t.isIdentifier(spec.exported)) {
+                    names.push(spec.exported.name);
+                }
+            }
+        }
+        if (t.isExportDefaultDeclaration(node)) {
+            names.push('default');
+        }
+    }
+    return names;
+}

package/dist/core/dev/generate/sanitize/index.server.d.ts

@@ -1,10 +1,3 @@
-/**
- * $ prefix-based sanitizer that rules:
- * - All server-only config properties begin with $ (e.g., $url, $hooks)
- * - All server-only field methods begin with $ (e.g., $beforeSave, $beforeRead)
- * - Content must be pure functions or imports from .server.ts files
- * - Outputs to .generated folder, preserving original folder structure
- */
 export function sanitize(): Promise<void>;
 /**
  * Updates imports in server files to use server versions of split modules

package/dist/core/dev/generate/sanitize/index.server.js

@@ -15,6 +15,11 @@ import { INPUT_DIR, OUTPUT_DIR } from '../../constants.js';
  * - Outputs to .generated folder, preserving original folder structure
  */
 
+// The top-level config — real, hand-authored. Unlike every other .server.ts file under
+// +rime/ (copied verbatim, server-only, no client counterpart needed), this one always needs
+// a sanitized client copy too — the panel still needs +rime.generated/rime.config.ts.
+const TOP_LEVEL_CONFIG = 'rime.config.server.ts';
+
 export async function sanitize() {
   const root = process.cwd();
   const configDir = path.resolve(root, 'src/lib/', INPUT_DIR);
@@ -66,12 +71,22 @@ export async function sanitize() {
     }
   }
 
-  // Also scan and copy all existing .server.ts files
-  const serverFiles = await scanServerFiles(configDir);
+  // Also scan and copy all existing .server.ts files — except the top-level config, which
+  // gets its own client+server split below instead of a plain verbatim copy.
+  const serverFiles = (await scanServerFiles(configDir)).filter(
+    (filePath) => path.relative(configDir, filePath) !== TOP_LEVEL_CONFIG
+  );
 
   // Scan and copy all other files (non-.ts files like .svelte, .json, etc.)
   const otherFiles = await scanOtherFiles(configDir);
 
+  // Top-level config split: same client/server treatment as every other split file below,
+  // just addressed by its fixed name instead of found via the scan (it's .server.ts-suffixed,
+  // so scanConfigFiles/allFiles never sees it). Runs after the pre-scan above so splitFiles is
+  // fully populated — this file's own `import { Pages } from './pages'`-style imports need to
+  // know which nested files themselves got split.
+  await processTopLevelConfig(configDir, outputDir, outputFiles, splitFiles);
+
   for (const filePath of allFiles) {
     const relativePath = path.relative(configDir, filePath);
     logger.debug(`   Processing: ${relativePath}`);
@@ -130,10 +145,13 @@ export async function sanitize() {
     }
   }
 
-  // Delete files that exist in current list but not in output list
+  // Delete files that exist in current list but not in output list. schema.server.ts is
+  // excluded — write.server.ts owns it (writes it straight into OUTPUT_DIR, see schemaPath()
+  // in constants.ts), sanitize() never adds it to outputFiles, so without this exclusion
+  // every sanitize run deletes it out from under write()'s own cache guard.
+  const SCHEMA_FILE = 'schema.server.ts';
   for (const existingFile of existingFiles) {
-    // Do not delete "schema.server.ts"
-    if (!outputFiles.has(existingFile) && existingFile !== 'schema.server.ts') {
+    if (existingFile !== SCHEMA_FILE && !outputFiles.has(existingFile)) {
       const fileToDelete = path.join(outputDir, existingFile);
       fs.unlinkSync(fileToDelete);
       logger.debug(`   Deleted: ${existingFile}`);
@@ -143,6 +161,40 @@ export async function sanitize() {
   logger.info('Sanitization complete');
 }
 
+/**
+ * The top-level config (src/lib/+rime/rime.config.server.ts) — real, hand-authored. Client
+ * copy via analyzeFile + sanitizeClientAst + removeUnusedImports, written into
+ * +rime.generated/, plus a server copy via updateServerImports so its own imports of nested
+ * split files resolve like every other split file's do.
+ */
+async function processTopLevelConfig(configDir, outputDir, outputFiles, splitFiles) {
+  const sourcePath = path.join(configDir, TOP_LEVEL_CONFIG);
+  if (!fs.existsSync(sourcePath)) return; // ensureUserConfigExist() already guards this
+
+  const content = fs.readFileSync(sourcePath, 'utf-8');
+  const ast = babelParse(content, 'ts', { sourceType: 'module', attachComment: false });
+  const analysis = analyzeFile(ast);
+
+  const clientPath = path.join(outputDir, 'rime.config.ts');
+  const serverPath = path.join(outputDir, TOP_LEVEL_CONFIG);
+  outputFiles.add(path.relative(outputDir, clientPath));
+  outputFiles.add(path.relative(outputDir, serverPath));
+
+  const clientAst = sanitizeClientAst(ast, analysis);
+  const cleanedAst = removeUnusedImports(clientAst);
+  const clientCode = generate(cleanedAst, { compact: false, comments: true }).code;
+  if (shouldWriteFile(clientPath, clientCode)) {
+    fs.writeFileSync(clientPath, clientCode);
+    logger.debug(`   Sanitized: rime.config.ts`);
+  }
+
+  const serverContent = updateServerImports(content, splitFiles, '.');
+  if (shouldWriteFile(serverPath, serverContent)) {
+    fs.writeFileSync(serverPath, serverContent);
+    logger.debug(`   Created: ${TOP_LEVEL_CONFIG}`);
+  }
+}
+
 async function scanConfigFiles(configDir) {
   const files = [];
 

package/dist/core/dev/generate/types/index.server.js

@@ -13,7 +13,6 @@ import { capitalize, toPascalCase } from '../../../../util/string.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { isInstalledDependency, OUTPUT_DIR } from '../../constants.js';
-import { buildRuntimeRegistry } from '../runtime/index.server.js';
 const IS_RIME_REPO = !isInstalledDependency(import.meta.url);
 // Relation  type
 const relationValueType = `
@@ -114,43 +113,20 @@ const templateDeclareVirtualModule = () => [
     `\texport * from '${PACKAGE_NAME}/config/server';`,
     `}`,
     `declare module '$rime/schema' {`,
-    `\texport * from '$lib/+rime.generated/schema.server.js';`,
-    `}`,
-    ...templateDeclareFieldModules()
+    `\texport * from '$lib/rime.schema.server.js';`,
+    `}`
+    // $rime/modules (the bare barrel) is typed by src/rime.modules.generated.d.ts instead —
+    // written directly by the Vite plugin's own dev-server watcher (regenerateModulesDeclaration
+    // in core/dev/vite/index.server.ts), not here, since it needs to react to module.(server.)ts
+    // files appearing/changing on their own, independent of a config regen.
+    //
+    // A package's own qualified $rime/modules/<pkg>/<path> references are self-contained —
+    // generate-manifest inserts a /// <reference> directly into each rewritten .d.ts file at
+    // prepack (see generate-manifest/index.server.ts), so this app never needs to know which
+    // installed packages exist or eagerly reference all of them; verified directly (a real tsc
+    // run resolves it correctly from a file two levels deep inside node_modules, zero consumer
+    // awareness needed).
 ].join('\n');
-/**
- * One `declare module '$rime/<name>'` per registered field module.ts + module.server.ts pair
- * (rime-native and consumer-local alike — see buildRuntimeRegistry), sourced from the
- * `.server.ts` side (the real, server-only implementation of the shared hook; the client
- * module.ts only has the no-op). Unrelated to type generation itself — that goes through
- * `field.use.generateType()` on the builder instance directly, not through this registry.
- * Runtime resolution (the Vite plugin's `load()`) is unaffected either way — it still picks
- * the real client-vs-server module dynamically based on build context.
- */
-const templateDeclareFieldModules = () => {
-    const registry = buildRuntimeRegistry();
-    return Array.from(registry.entries()).map(([name, entry]) => {
-        const modulePath = toModuleSpecifier(entry.server);
-        return `declare module '$rime/${name}' {\n\texport * from '${modulePath}';\n}`;
-    });
-};
-/**
- * `$lib/...` when the file is inside this app's own src/lib (true for a consumer's own custom
- * field, and for rime's own fields when developing rime itself, since they live inside src/lib
- * in that case too) — matches the `$rime/schema` declaration above, and stays readable/portable
- * instead of an absolute path. Falls back to an absolute path only when there's genuinely no
- * alias for it: rime's own fields when installed as a real dependency, living in
- * node_modules/rimecms/dist/, outside this app's src/lib entirely.
- */
-function toModuleSpecifier(serverPath) {
-    const libRoot = path.resolve(process.cwd(), 'src/lib');
-    const jsPath = serverPath.replace(/\.ts$/, '.js');
-    const relative = path.relative(libRoot, jsPath);
-    if (!relative.startsWith('..')) {
-        return `$lib/${relative.split(path.sep).join('/')}`;
-    }
-    return jsPath;
-}
 /**
  * Generates type definitions for image sizes
  * @returns A string containing the type definition for image sizes
@@ -283,6 +259,7 @@ export async function generateTypesString(config) {
     const blocksTypeNames = `export type BlockTypes = ${registeredBlocks.map((name) => `'${name}'`).join('|')}\n`;
     const anyBlock = `export type AnyBlock = ${registeredBlocks.map((name) => `Block${toPascalCase(name)}`).join('|')}\n`;
     const typeImports = `import type { ${Array.from(imports).join(', ')} } from '${PACKAGE_NAME}/types'`;
+    const rimeConfigServerPath = `./lib/${OUTPUT_DIR}/rime.config.server.ts`;
     const locals = `declare global {
   namespace App {
     interface Locals {
@@ -316,7 +293,7 @@ export async function generateTypesString(config) {
 			/** Singleton providing access to auth, config and local-api */
       rime: ReturnType<
 				Awaited<
-					typeof import('./lib/${OUTPUT_DIR}/rime.config.server.ts').default
+					typeof import('${rimeConfigServerPath}').default
 				>['createRimeContext']
 			>;
       /** Flag enabled by the core plugin rime.cache when the API cache is ON */
@@ -381,7 +358,7 @@ function write(key, content, filePath) {
  */
 async function generateTypes(config) {
     const mainTypes = await generateTypesString(config);
-    const declarations = [templateDeclareVirtualModule()].join('\n');
+    const declarations = templateDeclareVirtualModule();
     const appGeneratedPath = path.resolve(process.cwd(), 'src', 'app.generated.d.ts');
     const virtualModuleGeneratedPath = path.resolve(process.cwd(), 'src', 'rime.generated.d.ts');
     write('app.generated', mainTypes, appGeneratedPath);