rimecms 0.31.4 → 0.32.0

package/dist/core/dev/cli/generate-manifest/index.server.d.ts

@@ -1,17 +0,0 @@
-/**
- * Run at prepack, after `svelte-package` (operates on the compiled `dist/`, not `src/lib`) —
- * makes this package's own `$rime/modules` splits consumable by anyone who installs it:
- *
- * 1. Builds an export-name → split index from every module.(server.)js pair under `dist/`,
- *    validating it as it goes (see `buildModuleIndex` below) — a name that resolves
- *    ambiguously has no correct rewrite target in step 2, so this has to fail loudly here,
- *    not silently later.
- * 2. AST-rewrites every `import ... from '$rime/modules'` found anywhere under `dist/` into
- *    one `import ... from '$rime/modules/<pkg>/<subpath>'` per split it actually draws from —
- *    the bare barrel form never survives past this step.
- * 3. Writes `dist/.rime-modules.json` (subpath → real file paths, read directly by a
- *    consumer's Vite plugin — no fs.existsSync probing, no guessing) and
- *    `dist/.rime-modules.d.ts` (one `declare module '$rime/modules/<pkg>/<subpath>'` per
- *    split, referenced by a consumer's generated types).
- */
-export declare const generateManifest: () => void;

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

@@ -1,221 +0,0 @@
-import { generate } from '@babel/generator';
-import * as t from '@babel/types';
-import { babelParse } from 'ast-kit';
-import fs from 'node:fs';
-import path from 'node:path';
-import { logger } from '../../../logger/index.server.js';
-import { scanModulePairs } from '../../generate/runtime/index.server.js';
-import { parseExportNames } from '../../generate/runtime/parse-exports.server.js';
-import { getPackageInfoByKey } from '../util/package.server.js';
-/**
- * Run at prepack, after `svelte-package` (operates on the compiled `dist/`, not `src/lib`) —
- * makes this package's own `$rime/modules` splits consumable by anyone who installs it:
- *
- * 1. Builds an export-name → split index from every module.(server.)js pair under `dist/`,
- *    validating it as it goes (see `buildModuleIndex` below) — a name that resolves
- *    ambiguously has no correct rewrite target in step 2, so this has to fail loudly here,
- *    not silently later.
- * 2. AST-rewrites every `import ... from '$rime/modules'` found anywhere under `dist/` into
- *    one `import ... from '$rime/modules/<pkg>/<subpath>'` per split it actually draws from —
- *    the bare barrel form never survives past this step.
- * 3. Writes `dist/.rime-modules.json` (subpath → real file paths, read directly by a
- *    consumer's Vite plugin — no fs.existsSync probing, no guessing) and
- *    `dist/.rime-modules.d.ts` (one `declare module '$rime/modules/<pkg>/<subpath>'` per
- *    split, referenced by a consumer's generated types).
- */
-export const generateManifest = () => {
-    const pkgName = getPackageInfoByKey('name');
-    if (!pkgName) {
-        throw new Error("$rime generate-manifest: could not read this package's own name from package.json");
-    }
-    const distDir = path.resolve(process.cwd(), 'dist');
-    if (!fs.existsSync(distDir)) {
-        throw new Error(`$rime generate-manifest: no dist/ at ${distDir} — run this after svelte-package, not before`);
-    }
-    const pairs = scanModulePairs(distDir);
-    const nameOwner = buildModuleIndex(pairs);
-    rewriteBarrelImports(distDir, pkgName, nameOwner);
-    writeManifest(distDir, pkgName, pairs);
-    logger.info(`[✓] $rime/modules manifest generated for ${pkgName} (${pairs.size} split(s))`);
-};
-/**
- * Export-name → split index, with the two collision scenarios from the design doc handled
- * distinctly:
- * - module.ts and module.server.ts of the *same* split sharing a name — not a collision, that's
- *   the whole point of a pair (skip, both sides collapse to one entry). The two sides don't
- *   need to export the *same set* of names either — a server-only helper the client build
- *   never needs (e.g. cache's own `toHash`) is completely normal, not a broken pair; indexed
- *   from the union of both sides, worth a log for visibility, never a blocking error.
- * - two *different* splits exporting the same name — the actual collision. An ambiguous
- *   `$rime/modules` import has no correct rewrite target, so this is a hard error here, not a
- *   warning: it has to be caught before the rewrite runs, not after.
- */
-function buildModuleIndex(pairs) {
-    const nameOwner = new Map();
-    for (const [subpath, entry] of pairs) {
-        const serverNames = entry.server ? parseExportNames(entry.server) : [];
-        const clientNames = entry.client ? parseExportNames(entry.client) : [];
-        if (entry.server && entry.client) {
-            const serverSet = new Set(serverNames);
-            const clientSet = new Set(clientNames);
-            const onlyServer = serverNames.filter((name) => !clientSet.has(name));
-            const onlyClient = clientNames.filter((name) => !serverSet.has(name));
-            if (onlyServer.length || onlyClient.length) {
-                logger.debug(`$rime/modules: ${subpath} — module.ts and module.server.ts export different names ` +
-                    `(server-only: ${onlyServer.join(', ') || 'none'}, client-only: ${onlyClient.join(', ') || 'none'})`);
-            }
-        }
-        const names = new Set([...serverNames, ...clientNames]);
-        for (const name of names) {
-            const existing = nameOwner.get(name);
-            if (existing && existing !== subpath) {
-                throw new Error(`$rime/modules: "${name}" exported by both ${existing} and ${subpath}`);
-            }
-            nameOwner.set(name, subpath);
-        }
-    }
-    return nameOwner;
-}
-/**
- * `dist/.rime-modules.json` (runtime, read by a consumer's Vite plugin) and
- * `dist/.rime-modules.d.ts` (types, referenced by a consumer's generated types).
- *
- * Both store paths *relative to `distDir`*, not absolute — confirmed in practice that an
- * absolute path here is a real bug, not just a style choice: it bakes in wherever `dist/`
- * happened to sit on the machine that ran `generate-manifest`, and a consumer's Vite plugin
- * (`vite/index.server.ts`'s `load()`, third-party qualified form) re-joins it onto the
- * *installed* package's own root (`findInstalledPackageRoot`) at read time. On a real install
- * that absolute path wouldn't even exist; on the same dev machine the package was authored on
- * it silently reads the author's own working-copy `dist/` instead of what's actually installed
- * in the consumer's `node_modules` - stale-looking field/behavior drift with no error raised.
- *
- * The `.d.ts` needs a *different* relative shape than the runtime manifest, verified directly
- * (a real `tsc` run — a plain filesystem path, absolute or relative, silently resolves to zero
- * exports inside a `declare module` block; only a bare package-qualified specifier, resolved
- * through the same `node_modules` mechanism a real import would use, actually works): every
- * `export *` target is `<pkgName>/dist/<subpath-relative-to-dist>`.
- */
-function writeManifest(distDir, pkgName, pairs) {
-    const manifest = {};
-    const dts = [];
-    const relativeToDist = (target) => path.relative(distDir, target).split(path.sep).join('/');
-    for (const [subpath, entry] of pairs) {
-        manifest[subpath] = {
-            client: entry.client ? relativeToDist(entry.client) : undefined,
-            server: entry.server ? relativeToDist(entry.server) : undefined
-        };
-        const target = entry.server || entry.client;
-        const bareSpecifier = `${pkgName}/dist/${relativeToDist(target)}`.replace(/\.ts$/, '.js');
-        dts.push(`declare module '$rime/modules/${pkgName}/${subpath}' {\n  export * from '${bareSpecifier}';\n}`);
-    }
-    fs.writeFileSync(path.join(distDir, '.rime-modules.json'), JSON.stringify(manifest));
-    fs.writeFileSync(path.join(distDir, '.rime-modules.d.ts'), dts.join('\n\n') + '\n');
-}
-/**
- * Walks every `.js`/`.d.ts` file under `dist/`, rewriting `import ... from '$rime/modules'`
- * into one `import ... from '$rime/modules/<pkg>/<subpath>'` per split its specifiers actually
- * draw from — a single barrel import can (and often will) pull names from several different
- * splits at once, each becoming its own import statement.
- *
- * Every rewritten `.d.ts` file also gets a `/// <reference path="...">` to `.rime-modules.d.ts`
- * prepended, making it self-contained — verified directly (a real `tsc` run): without it, a
- * consumer never discovers the ambient `declare module '$rime/modules/<pkg>/...'` declarations
- * at all, *even from a file inside this same package*, since nothing imports `.rime-modules.d.ts`
- * and it's outside any project's own `include`. Doing it here means the *consumer* never needs
- * to know this package exists just to get its types working — no eager, app-side aggregation
- * of every installed rime-dependent package required.
- */
-function rewriteBarrelImports(distDir, pkgName, nameOwner) {
-    const walk = (dir) => {
-        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                walk(fullPath);
-                continue;
-            }
-            if (!entry.name.endsWith('.js') && !entry.name.endsWith('.d.ts'))
-                continue;
-            const content = fs.readFileSync(fullPath, 'utf-8');
-            if (!content.includes('$rime/modules'))
-                continue;
-            const ast = babelParse(content, 'ts', { sourceType: 'module', attachComment: true });
-            let changed = false;
-            const newBody = [];
-            for (const node of ast.body) {
-                // `import { x } from '$rime/modules'` (runtime .js) and the equivalent re-export
-                // `export { x } from '$rime/modules'` (declaration .d.ts, what tsc/svelte-package
-                // actually emits — a real end-to-end run caught this, not something guessable) both
-                // need the same treatment.
-                if (t.isImportDeclaration(node) && node.source.value === '$rime/modules') {
-                    changed = true;
-                    newBody.push(...splitBarrelImport(node, fullPath, pkgName, nameOwner));
-                    continue;
-                }
-                if (t.isExportNamedDeclaration(node) && node.source?.value === '$rime/modules') {
-                    changed = true;
-                    newBody.push(...splitBarrelReExport(node, fullPath, pkgName, nameOwner));
-                    continue;
-                }
-                if (t.isExportAllDeclaration(node) && node.source.value === '$rime/modules') {
-                    throw new Error(`$rime/modules: ${fullPath} does 'export * from $rime/modules' — ambiguous, can't tell which split each re-exported name belongs to. Import/re-export specific names instead.`);
-                }
-                newBody.push(node);
-            }
-            if (changed) {
-                ast.body = newBody;
-                const { code } = generate(ast, { compact: false, comments: true });
-                fs.writeFileSync(fullPath, entry.name.endsWith('.d.ts') ? withManifestReference(code, fullPath, distDir) : code);
-            }
-        }
-    };
-    walk(distDir);
-}
-function withManifestReference(code, fullPath, distDir) {
-    const relative = path
-        .relative(path.dirname(fullPath), path.join(distDir, '.rime-modules.d.ts'))
-        .split(path.sep)
-        .join('/');
-    const referencePath = relative.startsWith('.') ? relative : `./${relative}`;
-    return `/// <reference path="${referencePath}" />\n${code}`;
-}
-/** `import { x } from '$rime/modules'` (runtime .js) — groups specifiers by which split each
- *  name actually belongs to (via `nameOwner`, built by `buildModuleIndex`), one import
- *  statement per split. */
-function splitBarrelImport(node, fullPath, pkgName, nameOwner) {
-    const bySubpath = new Map();
-    for (const spec of node.specifiers) {
-        if (!t.isImportSpecifier(spec)) {
-            throw new Error(`$rime/modules: ${fullPath} imports the barrel with a default/namespace specifier — only named imports are supported`);
-        }
-        const importedName = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
-        const subpath = nameOwner.get(importedName);
-        if (!subpath) {
-            throw new Error(`$rime/modules: '${importedName}' imported in ${fullPath} but not exported by any split`);
-        }
-        if (!bySubpath.has(subpath))
-            bySubpath.set(subpath, []);
-        bySubpath.get(subpath).push(spec);
-    }
-    return Array.from(bySubpath.entries()).map(([subpath, specs]) => t.importDeclaration(specs, t.stringLiteral(`$rime/modules/${pkgName}/${subpath}`)));
-}
-/** `export { x } from '$rime/modules'` — what `tsc`/`svelte-package` actually emits in `.d.ts`
- *  output (a real end-to-end run caught this; `import`+`export` pairs aren't the only shape).
- *  Same grouping as `splitBarrelImport`, just keyed off `.local` (the name as it exists in the
- *  source module) instead of `.imported` — `ExportSpecifier` doesn't have that field. */
-function splitBarrelReExport(node, fullPath, pkgName, nameOwner) {
-    const bySubpath = new Map();
-    for (const spec of node.specifiers) {
-        if (!t.isExportSpecifier(spec)) {
-            throw new Error(`$rime/modules: ${fullPath} re-exports the barrel with a default/namespace specifier — only named exports are supported`);
-        }
-        const localName = spec.local.name;
-        const subpath = nameOwner.get(localName);
-        if (!subpath) {
-            throw new Error(`$rime/modules: '${localName}' re-exported in ${fullPath} but not exported by any split`);
-        }
-        if (!bySubpath.has(subpath))
-            bySubpath.set(subpath, []);
-        bySubpath.get(subpath).push(spec);
-    }
-    return Array.from(bySubpath.entries()).map(([subpath, specs]) => t.exportNamedDeclaration(null, specs, t.stringLiteral(`$rime/modules/${pkgName}/${subpath}`)));
-}

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

@@ -1,240 +0,0 @@
-import { logger } from '../../../logger/index.server.js';
-import { randomId } from '../../../../util/random.js';
-import { isValidSlug, slugify } from '../../../../util/string.js';
-import { generate as generateCode } from '@babel/generator';
-import * as t from '@babel/types';
-import { babelParse, getLang } from 'ast-kit';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { cp, mkdir } from 'fs/promises';
-import fs from 'node:fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { CONFIG_DIR, OUTPUT_DIR } from '../../constants.js';
-import { generate } from '../generate/index.server.js';
-import { installDependencies } from '../util/package-manager.server.js';
-import { getPackageInfoByKey } from '../util/package.server.js';
-import { prompt } from '../util/prompt.server.js';
-import * as templates from './templates.js';
-const PACKAGE = 'rimecms';
-const root = process.cwd();
-export const init = async ({ force, name: incomingName, skipInstall }) => {
-    const packageName = getPackageInfoByKey('name');
-    function setEnv() {
-        const envPath = path.resolve(root, '.env');
-        // Define variables with their update behavior
-        const envUpdates = {
-            BETTER_AUTH_SECRET: randomId(32),
-            PUBLIC_RIME_URL: 'http://localhost:5173',
-            RIME_CONFIG_DIR: CONFIG_DIR,
-            '# RIME_SMTP_USER': 'user@mail.com',
-            '# RIME_SMTP_PASSWORD': 'supersecret',
-            '# RIME_SMTP_PORT': '465',
-            '# RIME_SMTP_HOST': 'smtphost.com',
-            RIME_LOG_LEVEL: 'TRACE',
-            RIME_LOG_TO_FILE: 'true',
-            RIME_LOG_TO_FILE_MAX_DAYS: '1'
-        };
-        if (existsSync(envPath)) {
-            logger.info('[✓] .env file found');
-            let envContent = readFileSync(envPath, 'utf-8');
-            Object.entries(envUpdates).forEach(([key, value]) => {
-                const exists = envContent.match(new RegExp(`^${key}=`, 'm'));
-                if (!exists) {
-                    // Add new value if doesn't exist
-                    envContent += `\n${key}=${value}`;
-                    logger.info(`- ${key} added`);
-                }
-            });
-            writeFileSync(envPath, envContent);
-            logger.info('[✓] .env file populated');
-        }
-        else {
-            writeFileSync(envPath, templates.env());
-            logger.info('[✓] .env file created');
-        }
-    }
-    function setConfig(name) {
-        const configDirPath = path.resolve(root, CONFIG_DIR);
-        const configPath = path.join(configDirPath, 'rime.config.server.ts');
-        if (!existsSync(configPath)) {
-            if (!existsSync(configDirPath)) {
-                mkdirSync(configDirPath);
-            }
-            writeFileSync(configPath, templates.defaultConfig(name.toString()));
-            logger.info(`[✓] Config created at ${configDirPath}/rime.config.server.ts`);
-        }
-        else {
-            logger.info('[✓] Config already exists (skip)');
-        }
-    }
-    function setDatabase() {
-        const dbPath = path.join(root, 'db');
-        if (!existsSync(dbPath)) {
-            mkdirSync(dbPath);
-            logger.info('[✓] Database folder created');
-        }
-        else {
-            logger.info('[✓] Database folder already exists (skip)');
-        }
-    }
-    function addToGitignore() {
-        const gitignorePath = path.join(root, '.gitignore');
-        if (!existsSync(gitignorePath)) {
-            logger.warn('.gitignore not found (skip)');
-            return;
-        }
-        let gitignoreContent = readFileSync(gitignorePath, 'utf-8');
-        // OUTPUT_DIR is derived from RIME_CONFIG_DIR, so its first character isn't always '+' —
-        // escape every regex metacharacter generically instead of hand-picking one to backslash.
-        const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const updates = [
-            '.cache',
-            '/logs',
-            '/db',
-            OUTPUT_DIR,
-            'src/app.generated.d.ts',
-            'src/rime.generated.d.ts'
-        ];
-        if (!gitignoreContent.includes('# rime'))
-            gitignoreContent += '\n# rime';
-        for (const line of updates) {
-            const exists = gitignoreContent.match(new RegExp(`^${escapeRegExp(line)}`, 'm'));
-            if (!exists) {
-                // Add new value if doesn't exist
-                gitignoreContent += `\n${line}`;
-            }
-        }
-        writeFileSync(gitignorePath, gitignoreContent);
-        logger.info('[✓] .gitignore populated');
-    }
-    function setDrizzle(name) {
-        const drizzleConfigPath = path.join(root, 'drizzle.config.ts');
-        if (!existsSync(drizzleConfigPath)) {
-            writeFileSync(drizzleConfigPath, templates.drizzleConfig(name.toString()));
-            logger.info('[✓] Drizzle config added');
-            return;
-        }
-        logger.info(templates.regenerateDrizzleConfig(root)
-            ? '[✓] Drizzle config schema path updated'
-            : '[✓] Drizzle config already exists (skip)');
-    }
-    function configureVite() {
-        const configPath = path.resolve(root, 'vite.config.ts');
-        if (!fs.existsSync(configPath)) {
-            throw new Error("Can't find vite configuration file");
-        }
-        let content = fs.readFileSync(configPath, 'utf-8');
-        content = content.replace("from '@sveltejs/adapter-auto'", "from '@sveltejs/adapter-node'");
-        const program = babelParse(content, getLang(configPath));
-        const programBody = program.body;
-        const configObject = findSvelteConfigObject(programBody);
-        if (!configObject) {
-            throw new Error("Couldn't find the Vite config object (defineConfig({...}) or export default {...})");
-        }
-        const pluginsProp = configObject.properties.find((p) => t.isObjectProperty(p) && t.isIdentifier(p.key) && p.key.name === 'plugins');
-        if (!pluginsProp || !t.isArrayExpression(pluginsProp.value)) {
-            throw new Error("Couldn't find a `plugins: [...]` array in the Vite config object");
-        }
-        const pluginsArray = pluginsProp.value;
-        const alreadyPresent = pluginsArray.elements.some((el) => t.isCallExpression(el) && t.isIdentifier(el.callee) && el.callee.name === 'rime');
-        if (alreadyPresent) {
-            logger.info('[✓] Vite plugin already present (skip)');
-            return;
-        }
-        const hasImport = programBody.some((node) => t.isImportDeclaration(node) &&
-            node.source.value === `${PACKAGE}/vite` &&
-            node.specifiers.some((s) => t.isImportSpecifier(s) && t.isIdentifier(s.imported) && s.imported.name === 'rime'));
-        if (!hasImport) {
-            const importDecl = t.importDeclaration([t.importSpecifier(t.identifier('rime'), t.identifier('rime'))], t.stringLiteral(`${PACKAGE}/vite`));
-            programBody.unshift(importDecl);
-        }
-        const rimeCall = t.callExpression(t.identifier('rime'), []);
-        const sveltekitIndex = pluginsArray.elements.findIndex((el) => t.isCallExpression(el) && t.isIdentifier(el.callee) && el.callee.name === 'sveltekit');
-        if (sveltekitIndex !== -1) {
-            pluginsArray.elements.splice(sveltekitIndex + 1, 0, rimeCall);
-        }
-        else {
-            pluginsArray.elements.push(rimeCall);
-        }
-        const file = t.file(program);
-        const { code } = generateCode(file, {}, content);
-        fs.writeFileSync(configPath, code);
-        logger.info('[✓] Vite plugin added');
-    }
-    function findSvelteConfigObject(body) {
-        for (const node of body) {
-            if (t.isExpressionStatement(node) &&
-                t.isCallExpression(node.expression) &&
-                t.isIdentifier(node.expression.callee) &&
-                node.expression.callee.name === 'defineConfig') {
-                const arg = node.expression.arguments[0];
-                if (t.isObjectExpression(arg))
-                    return arg;
-            }
-            if (t.isExportDefaultDeclaration(node)) {
-                const decl = node.declaration;
-                if (t.isCallExpression(decl) &&
-                    t.isIdentifier(decl.callee) &&
-                    decl.callee.name === 'defineConfig') {
-                    const arg = decl.arguments[0];
-                    if (t.isObjectExpression(arg))
-                        return arg;
-                }
-                if (t.isObjectExpression(decl)) {
-                    return decl;
-                }
-            }
-        }
-        return null;
-    }
-    async function copyAssets() {
-        try {
-            const currentDir = path.dirname(fileURLToPath(import.meta.url));
-            await mkdir(path.resolve(process.cwd(), 'static/assets/panel/fonts'), { recursive: true });
-            await cp(path.join(currentDir, '../../../../panel/fonts'), path.resolve(process.cwd(), 'static/assets/panel/fonts'), {
-                recursive: true
-            });
-            logger.info('[✓] Copied assets');
-        }
-        catch (err) {
-            console.error('Error copying fonts:', err);
-        }
-    }
-    if (force || incomingName) {
-        const name = incomingName || packageName;
-        setEnv();
-        addToGitignore();
-        setConfig(name);
-        setDatabase();
-        setDrizzle(name);
-        configureVite();
-        await copyAssets();
-        !skipInstall && installDependencies();
-        await generate({ force: true });
-    }
-    else {
-        let name = '';
-        const defaultName = slugify(packageName);
-        let tries = 0;
-        while (!isValidSlug(name)) {
-            name = await prompt(tries > 0
-                ? 'Error: should contains only letters, numbers, hyphens, underscores\nWhat is your project name (will be used as database name) ?'
-                : 'What is your project name (will be used as database name) ?', defaultName || 'app');
-            tries++;
-        }
-        if (!name) {
-            logger.error('Operation cancelled');
-            process.exit(0);
-        }
-        setEnv();
-        addToGitignore();
-        setConfig(name);
-        setDatabase();
-        setDrizzle(name);
-        configureVite();
-        await copyAssets();
-        !skipInstall && installDependencies();
-        await generate({ force: true });
-        logger.info('[✓] done');
-    }
-};

package/dist/core/dev/cli/init/templates.d.ts

@@ -1,16 +0,0 @@
-export declare const env: () => string;
-export declare const defaultConfig: (name: string) => string;
-export declare const drizzleConfig: (name: string) => string;
-export declare const hooks: () => string;
-/** Writes src/hooks.server.ts if missing, or rewrites it if its content would differ from
- * what's expected now (e.g. after RIME_CONFIG_DIR changes the import path) — called both at
- * `rime init` and whenever the dev server detects a config change, so it never goes stale
- * between the two. Returns whether it wrote anything. */
-export declare function regenerateHooks(root?: string): boolean;
-/** Patches drizzle.config.ts's schema path line if it's stale (e.g. after RIME_CONFIG_DIR
- * changes) — only that one line, since the rest of the file may carry real customizations
- * (verbose, custom fields, etc.). Must run before generateSchema()'s own drizzle-kit
- * generate/migrate shell-out, which reads this file from disk. No-op if the file doesn't
- * exist — creating it from scratch needs a project name, which is `rime init`'s job
- * (setDrizzle() in init/index.server.ts). Returns whether it patched anything. */
-export declare function regenerateDrizzleConfig(root?: string): boolean;

package/dist/core/dev/cli/init/templates.js

@@ -1,105 +0,0 @@
-import { randomId } from '../../../../util/random.js';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
-import { CONFIG_DIR, GENERATED_DIR, configImportPaths } from '../../constants.js';
-const PACKAGE = 'rimecms';
-export const env = () => `BETTER_AUTH_SECRET=${randomId(32)}
-PUBLIC_RIME_URL=http://localhost:5173
-RIME_CONFIG_DIR=${CONFIG_DIR}
-
-# RIME_CACHE_ENABLED=false
-# RIME_SMTP_USER=user@mail.com
-# RIME_SMTP_PASSWORD=supersecret
-# RIME_SMTP_HOST=smtphost.com
-# RIME_SMTP_PORT=465
-
-RIME_CACHE_ENABLED=false
-RIME_LOG_LEVEL=TRACE
-RIME_LOG_TO_FILE=true
-RIME_LOG_TO_FILE_MAX_DAYS=1
-`;
-export const defaultConfig = (name) => `
-import { Collection, rime } from '$rime/config';
-import { text } from '${PACKAGE}/fields';
-import { adapterSqlite } from '${PACKAGE}/adapter-sqlite';
-
-const Pages = Collection.create('pages', {
-	fields: [text('title').isTitle()]
-});
-
-const Medias = Collection.create('medias', {
-  upload: true,
-	fields: [
-    text('alt').required(),
-  ]
-});
-
-export default rime({
-  $adapter: adapterSqlite('${name}.sqlite'),
-  collections: [Pages, Medias]
-});
-`;
-export const drizzleConfig = (name) => `
-import { defineConfig, type Config } from 'drizzle-kit';
-
-export const config: Config = {
-  schema: './${GENERATED_DIR}/schema.server.ts',
-  out: './db',
-  strict: false,
-  dialect: 'sqlite',
-  dbCredentials: {
-    url: './db/${name}.sqlite'
-  }
-};
-
-export default defineConfig(config);
-`;
-// Regenerated fresh by rime init every time (setHooks() only skips if the file already
-// exists, and `rime clear`/useConfig.js delete it first) — safe to make mode-aware.
-const HOOKS_DIR = path.resolve(process.cwd(), 'src');
-export const hooks = () => `import { sequence } from '@sveltejs/kit/hooks';
-import { handlers } from '${PACKAGE}/server';
-import config from '${configImportPaths(HOOKS_DIR).server}';
-
-export const handle = sequence(...(await handlers(config)));
-`;
-/** Writes src/hooks.server.ts if missing, or rewrites it if its content would differ from
- * what's expected now (e.g. after RIME_CONFIG_DIR changes the import path) — called both at
- * `rime init` and whenever the dev server detects a config change, so it never goes stale
- * between the two. Returns whether it wrote anything. */
-export function regenerateHooks(root = process.cwd()) {
-    const hooksPath = path.join(root, 'src', 'hooks.server.ts');
-    const srcDir = path.join(root, 'src');
-    const content = hooks();
-    if (!existsSync(hooksPath)) {
-        if (!existsSync(srcDir)) {
-            mkdirSync(srcDir, { recursive: true });
-        }
-        writeFileSync(hooksPath, content, 'utf-8');
-        return true;
-    }
-    if (readFileSync(hooksPath, 'utf-8') !== content) {
-        writeFileSync(hooksPath, content, 'utf-8');
-        return true;
-    }
-    return false;
-}
-const DRIZZLE_SCHEMA_LINE_REGEX = /^\s*schema:\s*['"][^'"]*['"],?\s*$/m;
-/** Patches drizzle.config.ts's schema path line if it's stale (e.g. after RIME_CONFIG_DIR
- * changes) — only that one line, since the rest of the file may carry real customizations
- * (verbose, custom fields, etc.). Must run before generateSchema()'s own drizzle-kit
- * generate/migrate shell-out, which reads this file from disk. No-op if the file doesn't
- * exist — creating it from scratch needs a project name, which is `rime init`'s job
- * (setDrizzle() in init/index.server.ts). Returns whether it patched anything. */
-export function regenerateDrizzleConfig(root = process.cwd()) {
-    const drizzleConfigPath = path.join(root, 'drizzle.config.ts');
-    if (!existsSync(drizzleConfigPath))
-        return false;
-    const expectedSchemaLine = `  schema: './${GENERATED_DIR}/schema.server.ts',`;
-    const content = readFileSync(drizzleConfigPath, 'utf-8');
-    if (DRIZZLE_SCHEMA_LINE_REGEX.test(content) && !content.includes(expectedSchemaLine)) {
-        writeFileSync(drizzleConfigPath, content.replace(DRIZZLE_SCHEMA_LINE_REGEX, expectedSchemaLine));
-        return true;
-    }
-    return false;
-}

package/dist/core/dev/cli/util/log.server.d.ts

@@ -1 +0,0 @@
-export declare const dim: (text: string) => void;

package/dist/core/dev/cli/util/log.server.js

@@ -1,4 +0,0 @@
-import chalk from 'chalk';
-export const dim = (text) => {
-    console.log(chalk.dim(text));
-};

package/dist/core/dev/constants.d.ts

@@ -1,29 +0,0 @@
-export declare const CONFIG_DIR: string;
-export declare const GENERATED_DIR: string;
-export declare const INPUT_DIR: string;
-export declare const OUTPUT_DIR: string;
-/** Turns an absolute path into an import specifier relative to `fromDir`, always prefixed
- * with `./` or `../` so it never gets mistaken for a bare package specifier. */
-export declare function relativeImportSpecifier(fromDir: string, toAbsolutePath: string): string;
-export declare function generatedConfigServerPath(): string;
-/** Where the panel/live route templates (common.server.ts) and the generated hooks.server.ts
- * should import the client/server config from — a relative import specifier computed from
- * `fromDir` (the absolute directory of the file doing the importing), so it resolves whether
- * GENERATED_DIR lives under src/lib or elsewhere. One source of truth instead of hardcoding the
- * path (or relying on the $lib alias, which only ever points at src/lib) at each call site. */
-export declare function configImportPaths(fromDir: string): {
-    client: string;
-    server: string;
-};
-/** Same idea as configImportPaths — one source of truth for where the generated schema
- * lives instead of hardcoding the path at each call site. */
-export declare function schemaPath(projectRoot?: string): string;
-/**
- * True when `metaUrl` (pass the caller's own `import.meta.url` — this can't be one shared
- * value, it depends on which file is asking) is running from inside an installed `rimecms`
- * package (node_modules/rimecms/...), false when running from rime's own repo. Deliberately
- * filesystem-based rather than an env var: a shell dotenv plugin auto-loading this repo's own
- * .env (which used to set IS_RIME_REPO=true) into every child process — including an unrelated
- * consumer app's dev server — made that value unreliable; this can't leak the same way.
- */
-export declare function isInstalledDependency(metaUrl: string): boolean;