rimecms 0.31.0 → 0.31.1

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

@@ -2,6 +2,7 @@ import { RIME_DEV_CACHE_DIR } from '../../../constant.server.js';
 import cache from '../../cache/index.server.js';
 import { sanitize } from '../../generate/sanitize/index.server.js';
 import { ensureGeneratedConfig, ensureUserConfigExist } from '../../../ensure.server.js';
+import { regenerateModulesDeclaration } from '../../vite/index.server.js';
 import { logger } from '../../../logger/index.server.js';
 import { trycatch } from '../../../../util/function.js';
 import { mkdirSync, rmSync } from 'fs';
@@ -67,6 +68,9 @@ export const generate = async (args) => {
         try {
             ensureUserConfigExist();
             await sanitizeConfig();
+            // Normal `vite dev` writes this from `configureServer`'s `listening` event, which never
+            // fires here — this command's own Vite server runs in `middlewareMode` (no `httpServer`).
+            regenerateModulesDeclaration();
             const importPathJS = ensureGeneratedConfig();
             logger.info('Starting vite server...');
             const vite = await createServer();

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

@@ -32,6 +32,10 @@ export declare function findModulePair(root: string, name: string): RuntimeRegis
  * `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/`).
  *
+ * A pair sitting directly in `root` itself (e.g. `src/lib/module.ts`, no subfolder) registers
+ * under the key `.` — same convention `package.json`'s own `exports` map uses for a package's
+ * root, and a folder literally named `.` can't exist, so it can never collide with a real one.
+ *
  * 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

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

@@ -57,6 +57,10 @@ export function findModulePair(root, name) {
  * `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/`).
  *
+ * A pair sitting directly in `root` itself (e.g. `src/lib/module.ts`, no subfolder) registers
+ * under the key `.` — same convention `package.json`'s own `exports` map uses for a package's
+ * root, and a folder literally named `.` can't exist, so it can never collide with a real one.
+ *
  * 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
@@ -66,17 +70,20 @@ export function scanModulePairs(root) {
     const registry = new Map();
     if (!fs.existsSync(root))
         return registry;
+    const register = (dir, key) => {
+        const client = findModuleFile(dir, 'module');
+        const server = findModuleFile(dir, 'module.server');
+        if (client || server) {
+            registry.set(key, { client: client ?? '', server: server ?? '' });
+        }
+    };
+    register(root, '.');
     const walk = (dir) => {
         for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
             if (!entry.isDirectory() || entry.name === OUTPUT_DIR)
                 continue;
             const fullPath = path.join(dir, entry.name);
-            const client = findModuleFile(fullPath, 'module');
-            const server = findModuleFile(fullPath, 'module.server');
-            if (client || server) {
-                const key = path.relative(root, fullPath).split(path.sep).join('/');
-                registry.set(key, { client: client ?? '', server: server ?? '' });
-            }
+            register(fullPath, path.relative(root, fullPath).split(path.sep).join('/'));
             walk(fullPath);
         }
     };

package/dist/core/dev/vite/index.server.d.ts

@@ -1,2 +1,3 @@
 import type { Plugin } from 'vite';
+export declare function regenerateModulesDeclaration(): void;
 export declare function rime(): Plugin;

package/dist/core/dev/vite/index.server.js

@@ -38,6 +38,20 @@ function splitPackageSpecifier(rest) {
     const subpath = segments.slice(pkgName.split('/').length).join('/');
     return { pkgName, subpath };
 }
+// Writes the local-dev $rime/modules barrel types from every module.(server.)ts pair under
+// src/lib. Exported so the CLI `generate` command can call it too — its Vite server runs in
+// middlewareMode, which never fires the `listening` event `rime()` normally hooks this to.
+export function regenerateModulesDeclaration() {
+    const libDir = path.resolve(process.cwd(), 'src/lib');
+    const pairs = scanModulePairs(libDir);
+    const exports = Array.from(pairs.values())
+        .map((entry) => entry.server || entry.client)
+        .filter(Boolean)
+        .map((file) => `$lib/${path.relative(libDir, file).split(path.sep).join('/')}`.replace(/\.ts$/, '.js'))
+        .map((aliased) => `  export * from '${aliased}';`)
+        .join('\n');
+    writeFileSync(path.resolve(process.cwd(), 'src/rime.modules.generated.d.ts'), `declare module '$rime/modules' {\n${exports}\n}\n`);
+}
 export function rime() {
     /** Two reserved names, always resolved to *the currently running app's* generated
      *  config/schema, independent of who's asking — a third-party plugin importing
@@ -46,28 +60,19 @@ export function rime() {
      *  namespace only by convention. */
     const VCoreId = '$rime/config';
     const VSchemaId = '$rime/schema';
-    /** `$rime/modules` — a package's own client/server split, resolved relative to *whoever's
-     *  asking*, always self-contained. Two forms:
+    /**
+     * `$rime/modules` lets a package split its code into client and server files.
+     *
+     * While developing, you can just write `$rime/modules` with no path and it scans this
+     * project's own `src/lib` for every split. Before the package is published, that gets
+     * rewritten into explicit imports like `$rime/modules/<pkg>/<path>` — so anyone installing
+     * the package never sees the bare form, only real paths.
+     *
+     * When resolving one of those explicit imports: if `<pkg>` is this same project, we read
+     * straight from `src/lib`. Otherwise it's a real dependency, so we find it in
+     * `node_modules` and read the file list it shipped.
      *
-     *  - The bare barrel, `$rime/modules`, addressed by *export name* rather than path — dev
-     *    only, live-scans this project's own `src/lib` for every `module.(server.)ts` pair (see
-     *    `regenerateModulesDeclaration` below for the matching local-dev `.d.ts`). Never ships:
-     *    a prepack step (the `generate-manifest` CLI command) AST-rewrites every `$rime/modules`
-     *    import into the qualified form below before publish, so a consumer never sees the
-     *    barrel at all.
-     *  - The qualified form, `$rime/modules/<pkg>/<path>`, always package-qualified — even for a
-     *    package's own internal references to itself. Two ways it resolves, both in `resolveId`
-     *    (not `load`, which never receives `importer`): `<pkg>` equals this project's own
-     *    `package.json` name → self-reference, resolved directly off this project's own
-     *    `src/lib`. Otherwise → an installed dependency, its root found by walking up
-     *    `node_modules/<pkg>` from the importer's own directory (`findInstalledPackageRoot` —
-     *    pure directory existence, no `exports`-conditions matching, since a package whose
-     *    `exports` map declares only conditions neither `require.resolve` nor
-     *    `import.meta.resolve` use fails to resolve through either) and its shipped
-     *    `dist/.rime-modules.json` read directly — no directory-convention guessing beyond that,
-     *    immune to Vite's dep-optimizer flattening a package (reading a known filename off disk
-     *    never touches the import graph the optimizer rewrites). Full design:
-     *    docs/plans/imports.md. */
+     */
     const VModulesId = '$rime/modules';
     const VModulesPrefix = '$rime/modules/';
     const ownPackageName = getPackageInfoByKey('name');
@@ -77,25 +82,6 @@ export function rime() {
     // doesn't receive importer); the barrel and self-reference cases carry no baked-in root.
     const ROOT_SEP = '\x01';
     const resolvedVModule = (name) => '\0' + name;
-    // Local-dev types for the $rime/modules barrel — declares every module.(server.)ts pair
-    // currently under this project's own src/lib, live. Regenerated on startup and whenever a
-    // module file appears/changes/disappears (see the watcher below) — never ships, gitignored,
-    // same treatment as app.generated.d.ts/rime.generated.d.ts.
-    //
-    // $lib/-aliased paths, not bare relative/absolute ones — verified directly (a plain relative
-    // or absolute `export * from` inside a `declare module` block silently resolves to no
-    // exports at all; TS only picks up the re-exported names through a real configured alias).
-    function regenerateModulesDeclaration() {
-        const libDir = path.resolve(process.cwd(), 'src/lib');
-        const pairs = scanModulePairs(libDir);
-        const exports = Array.from(pairs.values())
-            .map((entry) => entry.server || entry.client)
-            .filter(Boolean)
-            .map((file) => `$lib/${path.relative(libDir, file).split(path.sep).join('/')}`.replace(/\.ts$/, '.js'))
-            .map((aliased) => `  export * from '${aliased}';`)
-            .join('\n');
-        writeFileSync(path.resolve(process.cwd(), 'src/rime.modules.generated.d.ts'), `declare module '$rime/modules' {\n${exports}\n}\n`);
-    }
     return {
         name: 'virtual-rime',
         configureServer(server) {
@@ -196,9 +182,6 @@ export function rime() {
                 },
                 server: {
                     watch: {
-                        // db/*.sqlite (+ its -wal/-shm sidecars) and logs/ are runtime data, not source —
-                        // every write (e.g. saving a document) touches them, and without this Vite's default
-                        // whole-project-root watch treats that churn as a source change and force-reloads.
                         ignored: ['**/db/**', '**/logs/**']
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rimecms",
-  "version": "0.31.0",
+  "version": "0.31.1",
   "homepage": "https://github.com/bienbiendev/rime",
   "scripts": {
     "dev": "vite dev",
@@ -96,6 +96,8 @@
     "vite": "^8.0.8"
   },
   "devDependencies": {
+    "@changesets/changelog-github": "^1.0.0",
+    "@changesets/cli": "^3.0.1",
     "@eslint/compat": "^1.2.5",
     "@eslint/js": "^9.18.0",
     "@sveltejs/adapter-node": "^5.5.4",