clivly 0.10.7 → 0.10.9

package/index.mjs

@@ -2,7 +2,7 @@
 import { t as CANONICAL_FIELDS } from "./entity-config-bC3DX9f1.mjs";
 import "./mapping-score-C68uAqGB.mjs";
 import { hasDefiningColumn, isFrameworkTable, matchesConcept, requiredFieldsFor, scoreFieldMap, scoreRelationships, suggestCursorField, toFieldMap } from "./internal-entity-heuristics.mjs";
-import { s as isPlaceholderUrl, t as createClivlySDK } from "./sdk-BTzaM8bF.mjs";
+import { s as isPlaceholderUrl, t as createClivlySDK } from "./sdk-DofHordq.mjs";
 import { createRequire } from "node:module";
 import { spawn } from "node:child_process";
 import { accessSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, watch, writeFileSync } from "node:fs";
@@ -292,6 +292,124 @@ function addCommand(pm, packages) {
 	};
 }
 //#endregion
+//#region src/detect-workspace.ts
+const SELECTABLE_FRAMEWORKS = [
+	"nextjs",
+	"tanstack-start",
+	"sveltekit",
+	"remix",
+	"nuxt"
+];
+/**
+* Validate a `--framework` value.
+*
+* Rejecting a typo matters more than accepting one leniently: an unrecognised
+* value silently falling back to detection would scaffold route files in the
+* wrong shape, and a route in the wrong shape is not a build error — the
+* generator simply skips it and the endpoint 404s at runtime.
+*/
+function parseFrameworkFlag(value) {
+	if (value === void 0) return;
+	if (SELECTABLE_FRAMEWORKS.includes(value)) return value;
+	throw new Error(`"${value}" is not a supported framework. Accepted: ${SELECTABLE_FRAMEWORKS.join(", ")}.`);
+}
+/**
+* A caution for when the framework came from a sibling package, or null.
+*
+* Borrowing the ORM or auth is unambiguous — one database and one auth instance
+* serve the whole workspace. Borrowing the *framework* is not: route files are
+* generated in that framework's shape and written into the directory `init` ran
+* in, so if the framework lives next door the routes probably belong next door
+* too. Writing TanStack `src/routes/` files into a Hono app is not a build
+* error — the route generator simply never sees them and the endpoints 404.
+*/
+function borrowedFrameworkWarning(framework, source) {
+	if (!source) return null;
+	return `  ⚠️  ${FRAMEWORK_LABELS[framework]} was detected in "${source}", not here.\n      Route files are generated in that framework's shape. If this app
+      does not serve them, run init inside "${source}" instead, or pass\n      --framework to say what this app actually is.
+`;
+}
+/**
+* Extra guidance for a detection failure inside a workspace, or "" outside one.
+*
+* Detection has already scanned every sibling by the time either failure fires,
+* so the marker really is absent everywhere — which is worth saying, because
+* the bare message sends a developer looking for a dependency that was never
+* missing. Returning "" for the single-package case keeps the caller
+* branch-free.
+*/
+function workspaceHint(kind, packageCount) {
+	if (packageCount === 0) return "";
+	const scanned = `\nScanned ${packageCount} workspace package(s) and found no ${kind === "orm" ? "ORM" : "framework"} marker`;
+	return kind === "orm" ? `${scanned}.\nIf your schema is Drizzle, point at it and init will take your word:\n\n  clivly init --schema <path-or-package>\n` : `${scanned}\nin any of them. If this app is served by one of the frameworks above,\nname it outright:\n\n  clivly init --framework tanstack-start\n`;
+}
+/**
+* Resolve one signal, preferring the app's own dependencies.
+*
+* The app's package.json is authoritative: a sibling on a different framework
+* must never redefine what this app is. Only when the app itself is silent do
+* we look outward, and then the first package by name wins.
+*
+* Sorting here rather than trusting the caller matters: the real package list
+* comes from glob expansion, whose order is not guaranteed, so an unsorted scan
+* would let the same repo detect differently between runs and report a
+* different package as the source.
+*/
+function resolveSignal(appDeps, packages, detect, unknown) {
+	const own = detect(appDeps);
+	if (own !== unknown) return {
+		source: null,
+		value: own
+	};
+	const ordered = [...packages].sort((a, b) => a.name.localeCompare(b.name));
+	for (const pkg of ordered) {
+		const found = detect(pkg.deps);
+		if (found !== unknown) return {
+			source: pkg.name,
+			value: found
+		};
+	}
+	return {
+		source: null,
+		value: unknown
+	};
+}
+/**
+* Detect framework, ORM and auth across a whole workspace.
+*
+* A monorepo routinely splits these across packages — framework in the frontend
+* app, ORM in a `db` package, auth in an `auth` package — so reading only the
+* directory `init` was run from finds at most one of the three and fails
+* whichever way the developer turns. Widening the search to sibling packages is
+* what makes those layouts installable.
+*
+* Detection is deliberately a union rather than a per-package view: `init`
+* generates one config for one app, and that app reaches its database and auth
+* through workspace dependencies whether or not they are named in its own
+* manifest.
+*
+* `packages` may include the app itself; that is harmless, since the app's own
+* deps are consulted first anyway. Pass `[]` outside a workspace, which reduces
+* this to a plain single-package read.
+*/
+function detectAcrossWorkspace(appDeps, packages) {
+	const framework = resolveSignal(appDeps, packages, detectFramework, "unknown");
+	const orm = resolveSignal(appDeps, packages, detectOrm, "unknown");
+	const auth = resolveSignal(appDeps, packages, detectAuth, "unknown");
+	const sources = {
+		auth: auth.source,
+		framework: framework.source,
+		orm: orm.source
+	};
+	return {
+		auth: auth.value,
+		borrowed: Object.values(sources).some((source) => source !== null),
+		framework: framework.value,
+		orm: orm.value,
+		sources
+	};
+}
+//#endregion
 //#region src/tick-route.ts
 /**
 * The tick route's public URL path, and the template `clivly login` writes for
@@ -1257,10 +1375,12 @@ Usage:
   clivly init [--force] [--dry-run] [--diff] [--yes] [--no-login] [--no-browser]
               [--schema <path|package>] [--db-import <specifier>]
               [--auth-import <specifier>] [--contact-table <table>]
-              [--company-table <table>]
+              [--company-table <table>] [--framework <name>]
 
 Scaffolds clivly.config.ts, the Clivly route files, and .env placeholders.
 Detects your framework, ORM, auth adapter and app layout from the project.
+In a workspace the whole package graph is scanned, so a monorepo that keeps
+its framework, ORM and auth in separate packages is detected from any app.
 
 Options:
   --dry-run            Show what would be written; write nothing
@@ -1268,7 +1388,8 @@ Options:
   --force              Overwrite files Clivly owns
   --yes                Skip prompts
   --no-login           Skip browser pairing
-  --schema <p>         Path or package holding your ORM schema
+  --framework <n>      nextjs | tanstack-start | sveltekit | remix | nuxt
+  --schema <p>         Path or package holding your ORM schema (implies Drizzle)
   --db-import <s>      Module specifier exporting your database instance
   --auth-import <s>    Module specifier exporting your auth instance
   --contact-table <t>  Table to map as contacts
@@ -1700,13 +1821,52 @@ function toScoredTable(table) {
 function columnNames(table) {
 	return table.columns.map((column) => column.dbName);
 }
-function rankCandidates$1(tables, concept) {
+/**
+* Company candidates the vocabulary cannot name, promoted on foreign-key
+* evidence.
+*
+* The company vocabulary is seven generic business words (companies,
+* organizations, teams, accounts…). A domain word for the same idea —
+* `campuses`, `branches`, `sites`, `practices`, `chapters` — matches none of
+* them, so such a table was never a candidate at all and no amount of ranking
+* could reach it. On `vue-academy` that left Better Auth's `organization` as
+* the only company candidate, and init duly scaffolded the auth table while
+* `campuses`, which every student row references, was invisible.
+*
+* Guessing more words does not fix this; the next unlisted word fails
+* identically. The schema already states the answer: when the CONTACT table
+* holds a real foreign key to some table, that target is what a contact
+* belongs to. `references` is reflected metadata, so this is a fact rather
+* than a name guess.
+*
+* Two guards keep it honest. The target must pass `hasDefiningColumn`, the
+* same "can this table BE a company" test every other candidate passes — a
+* join table with no `name` is not promoted. And framework tables are skipped,
+* because `contacts.organization_id → organization` is exactly the auth
+* plumbing this is meant to see past.
+*/
+function fkPromotedCompanies(tables, contact) {
+	if (!contact) return [];
+	const targets = /* @__PURE__ */ new Set();
+	for (const column of contact.columns) {
+		const table = column.references?.table;
+		if (table && !isFrameworkTable(table)) targets.add(table.toLowerCase());
+	}
+	return tables.filter((t) => targets.has(t.tableName.toLowerCase()) && t.tableName !== contact.tableName && hasDefiningColumn("company", columnNames(t)));
+}
+function rankCandidates$1(tables, concept, contact = null) {
+	const promoted = concept === "company" ? fkPromotedCompanies(tables, contact) : [];
+	const promotedNames = new Set(promoted.map((t) => t.tableName));
 	return tables.map((t) => ({
 		t,
-		m: matchesConcept(t.tableName, concept)
+		m: matchesConcept(t.tableName, concept) ?? (promotedNames.has(t.tableName) ? { exact: false } : null)
 	})).filter((c) => Boolean(c.m)).sort((a, b) => {
 		const usable = Number(hasDefiningColumn(concept, columnNames(b.t))) - Number(hasDefiningColumn(concept, columnNames(a.t)));
 		if (usable !== 0) return usable;
+		const aPromoted = promotedNames.has(a.t.tableName);
+		if (aPromoted !== promotedNames.has(b.t.tableName)) {
+			if (isFrameworkTable((aPromoted ? b.t : a.t).tableName)) return aPromoted ? -1 : 1;
+		}
 		const exact = Number(b.m.exact) - Number(a.m.exact);
 		if (exact !== 0) return exact;
 		return Number(isFrameworkTable(a.t.tableName)) - Number(isFrameworkTable(b.t.tableName));
@@ -1714,7 +1874,7 @@ function rankCandidates$1(tables, concept) {
 }
 function selectEntities(tables) {
 	const contactCands = rankCandidates$1(tables, "contact");
-	const companyCands = rankCandidates$1(tables, "company");
+	const companyCands = rankCandidates$1(tables, "company", contactCands[0] ?? null);
 	const contactNames = new Set(contactCands.map((t) => t.tableName));
 	const companyNames = new Set(companyCands.map((t) => t.tableName));
 	const contactExclusive = contactCands.filter((t) => !companyNames.has(t.tableName));
@@ -1952,14 +2112,19 @@ export async function register() {
 		return;
 	}
 	try {
-		// Built at runtime so the bundler cannot statically trace it. Next
-		// compiles this file for BOTH runtimes, and the guard above only runs on
-		// the edge — it does not stop the edge BUILD from following a literal
-		// import into your config, and from there into your database driver. A
-		// node-postgres app fails that pass on \`require('path')\` and every route
-		// 500s before Clivly is ever reached.
-		const specifier = "${importPath}";
-		const { default: clivly } = await import(/* webpackIgnore: true */ specifier);
+		// A plain import, deliberately. Next compiles this file for BOTH runtimes
+		// and follows this into your config and on into your database driver, so a
+		// Node-only driver breaks the EDGE build — the guard above is a runtime
+		// check and cannot prevent that. The fix belongs in next.config, where
+		// \`clivly init\` writes an edge-only \`config.externals\` entry; nothing here
+		// ever executes on the edge, so the driver only has to resolve.
+		//
+		// Do NOT make this untraceable (a variable specifier, webpackIgnore).
+		// That silences the build error and breaks the app in a worse way:
+		// clivly.config is TypeScript, so an unbundled import cannot load it, and
+		// the catch below turns that into a warning — the app boots, serves
+		// traffic, and never checks in.
+		const { default: clivly } = await import("${importPath}");
 		await clivly.start();
 	} catch (error) {
 		console.warn("[clivly] could not check in:", error);
@@ -2012,6 +2177,46 @@ function nextNeedsInstrumentationFlag(versionRange) {
 }
 const NEXT_INSTRUMENTATION_FLAG_STEP = `Your Next.js version reads instrumentation.ts only when it is switched on. Add this to next.config, or Clivly will never be told your app started:
       experimental: { instrumentationHook: true }`;
+const NODE_ONLY_DRIVERS = /* @__PURE__ */ new Set([
+	"pg",
+	"mysql",
+	"mysql2",
+	"better-sqlite3",
+	"sqlite3",
+	"tedious",
+	"oracledb",
+	"ioredis"
+]);
+/**
+* The Node-only database drivers a config's dependency list contains.
+*
+* Next compiles instrumentation.ts for the edge runtime whether or not the app
+* uses it, and follows the boot hook's config import into the driver. `pg`
+* pulls in `pgpass` → `split2` → `stream`, none of which resolve there, so the
+* build fails and every route 500s — before any Clivly code runs.
+*
+* `serverExternalPackages` does NOT fix this. It applies to the Node server
+* bundle only; the edge pass ignores it entirely, which is why adding package
+* after package to it never terminates. An edge-only `config.externals` is what
+* works, and it is safe precisely because nothing in that bundle ever executes
+* — the boot hook returns early unless NEXT_RUNTIME is "nodejs".
+*/
+function nodeOnlyDrivers(dependencies) {
+	if (!dependencies) return [];
+	return Object.keys(dependencies).filter((name) => NODE_ONLY_DRIVERS.has(name)).sort();
+}
+/** The next.config step an app needs when its config reaches a Node driver. */
+function nextEdgeExternalsStep(drivers) {
+	const list = drivers.map((d) => `"${d}"`).join(", ");
+	return `Your database driver (${drivers.join(", ")}) cannot be bundled for Next's edge runtime, which compiles instrumentation.ts whether or not you use it. Without this, every route fails to build. Add to next.config:
+      webpack: (config, { nextRuntime }) => {
+        if (nextRuntime === "edge") {
+          config.externals = [...(config.externals ?? []), ${list}];
+        }
+        return config;
+      }
+    Nothing runs on the edge — the boot hook exits early there — so the driver only has to resolve.`;
+}
 const REMIX_BOOT_STEP = `Start Clivly when your app boots. Add this near the top of app/entry.server.tsx:
       import clivly from "./clivly.config";
       clivly.start().catch((error) => console.warn("[clivly] could not check in:", error));`;
@@ -2562,21 +2767,32 @@ function planEnv(args) {
 		action: envAction(addedKeys.length, existing.length)
 	};
 }
-function declaredNextVersion(args) {
+function hostManifest(args) {
 	const raw = args.readFile(join(args.cwd, "package.json"));
-	if (!raw) return;
-	let pkg = {};
+	if (!raw) return {};
 	try {
-		pkg = JSON.parse(raw);
+		return JSON.parse(raw);
 	} catch {
-		pkg = {};
+		return {};
 	}
+}
+function declaredNextVersion(args) {
+	const pkg = hostManifest(args);
 	return pkg.dependencies?.next ?? pkg.devDependencies?.next;
 }
+function declaredDependencies(args) {
+	return hostManifest(args).dependencies;
+}
+/** The edge-externals step, or null when no Node-only driver is declared. */
+function edgeExternalsStepFor(dependencies) {
+	const drivers = nodeOnlyDrivers(dependencies);
+	return drivers.length > 0 ? nextEdgeExternalsStep(drivers) : null;
+}
 function planBootPatch(args) {
 	if (bootHookPath(args.framework, args.layout) !== null) return {
 		file: null,
-		manual: args.framework === "nextjs" && nextNeedsInstrumentationFlag(declaredNextVersion(args)) ? NEXT_INSTRUMENTATION_FLAG_STEP : null
+		manual: args.framework === "nextjs" && nextNeedsInstrumentationFlag(declaredNextVersion(args)) ? NEXT_INSTRUMENTATION_FLAG_STEP : null,
+		extra: args.framework === "nextjs" ? edgeExternalsStepFor(declaredDependencies(args)) : null
 	};
 	if (args.framework === "remix") return {
 		file: null,
@@ -2622,7 +2838,7 @@ function planMutations(args) {
 	return {
 		files,
 		env: planEnv(args),
-		manualSteps: boot.manual ? [boot.manual] : []
+		manualSteps: [boot.manual, boot.extra ?? null].filter((step) => step !== null)
 	};
 }
 function planWidgetMutations(args) {
@@ -3905,6 +4121,18 @@ function resolveInitDeps(options) {
 		authWiring: renderAuthWiring("unknown")
 	};
 }
+/**
+* The three detection lines, annotating any signal borrowed from a sibling.
+*
+* Naming the source package is what makes a workspace detection auditable:
+* without it the banner claims an ORM the developer cannot find in the
+* directory they are standing in.
+*/
+function renderDetectionLines(detection) {
+	const from = (source) => source ? ` (from ${source})` : "";
+	const frameworkNote = detection.frameworkForced ? " (--framework)" : from(detection.sources.framework);
+	return `  Framework: ${FRAMEWORK_LABELS[detection.framework]}${frameworkNote}\n  ORM:       ${detection.orm}${from(detection.sources.orm)}\n  Auth:      ${detection.auth}${from(detection.sources.auth)}${detection.authWired ? " (wired)" : ""}\n`;
+}
 async function acquireSchema(options, deps) {
 	const { out } = deps;
 	const appDeps = deps.readDepsFn(options.cwd);
@@ -3912,26 +4140,39 @@ async function acquireSchema(options, deps) {
 		out(`No package.json found in ${options.cwd}. Run \`clivly init\` from inside an existing app — cd into your project first.\n`);
 		return { code: 1 };
 	}
-	const framework = detectFramework(appDeps);
-	const orm = detectOrm(appDeps);
-	const auth = detectAuth(appDeps);
+	const workspacePackages = (deps.graphFor(options.cwd)?.packages ?? []).map((pkg) => ({
+		deps: deps.readDepsFn(pkg.dir),
+		name: pkg.name
+	}));
+	const detected = detectAcrossWorkspace(appDeps, workspacePackages);
+	const framework = options.frameworkFlag ?? detected.framework;
+	const { auth, orm, sources } = detected;
 	deps.framework = framework;
 	const layout = deps.resolveAppLayout(options.cwd, deps.fileExists);
 	deps.layout = layout;
 	out("\nClivly init\n");
 	deps.authWiring = renderAuthWiring(auth, auth === "better-auth" ? authInstanceFromFlag(options.authImportFlag) ?? await deps.probeAuth(options.cwd) : null);
-	out(`  Framework: ${FRAMEWORK_LABELS[framework]}\n`);
-	out(`  ORM:       ${orm}\n`);
-	out(`  Auth:      ${auth}${deps.authWiring.complete ? " (wired)" : ""}\n`);
+	out(renderDetectionLines({
+		auth,
+		authWired: deps.authWiring.complete,
+		framework,
+		frameworkForced: options.frameworkFlag !== void 0,
+		orm,
+		sources
+	}));
 	if (framework === "nextjs") out(`  Layout:    ${layout}\n`);
+	const frameworkCaution = options.frameworkFlag ? null : borrowedFrameworkWarning(framework, sources.framework);
+	if (frameworkCaution) out(`\n${frameworkCaution}`);
 	if (auth === "better-auth" && !deps.authWiring.complete) out("\n  ⚠️  Could not locate your better-auth instance.\n      The verify route will import a placeholder path that does not\n      resolve. Point it at the real module with:\n\n        clivly init --force --auth-import <specifier>\n\n      Accepts an alias ($lib/server/auth, @/lib/auth), a package name,\n      or a project-relative path (src/lib/server/auth).\n");
 	out("\n");
-	if (orm !== "drizzle") {
+	if (orm !== "drizzle" && !options.schemaFlag) {
 		out(`clivly init currently generates config for Drizzle only. Detected ORM: ${orm}\n`);
+		out(workspaceHint("orm", workspacePackages.length));
 		return { code: 1 };
 	}
 	if (framework === "unknown") {
 		out("clivly init doesn't recognise your framework yet (looked for Next.js, TanStack Start, SvelteKit, Remix, Nuxt). Route file generation needs one of these.\n");
+		out(workspaceHint("framework", workspacePackages.length));
 		if ("vue" in appDeps) out("\nUsing Vue? Clivly supports Vue through Nuxt. A Vite SPA has no server\nto mount the sync route on, so the route files need Nuxt's server\ndirectory (or any of the frameworks above).\n");
 		return { code: 1 };
 	}
@@ -4029,6 +4270,10 @@ function previewMutations(deps, mutations, options) {
 		out(`  ${mutations.env.action.padEnd(9)} .env\n`);
 		for (const key of mutations.env.addedKeys) out(`              + ${key}=\n`);
 	}
+	if (mutations.manualSteps.length > 0) {
+		out("\nYou will also need to:\n");
+		for (const step of mutations.manualSteps) out(`\n  ! ${step}\n`);
+	}
 	out(options.diff ? "\nRe-run without --diff to apply; --force to overwrite the files marked conflict.\n" : "\nRe-run without --dry-run to apply.\n");
 }
 function printNextSteps(out, authComplete, loginRan, envFile, needsViteDotenv = false) {
@@ -4355,6 +4600,13 @@ function defaultLoginDeps() {
 	};
 }
 function runInitFromArgv(argv, cwd) {
+	let frameworkFlag;
+	try {
+		frameworkFlag = parseFrameworkFlag(flagValue(argv, "--framework"));
+	} catch (error) {
+		process.stdout.write(`${error.message}\n`);
+		return Promise.resolve(1);
+	}
 	return runInit({
 		cwd,
 		force: argv.includes("--force"),
@@ -4364,6 +4616,7 @@ function runInitFromArgv(argv, cwd) {
 		noLogin: argv.includes("--no-login"),
 		openBrowser: !argv.includes("--no-browser"),
 		schemaFlag: flagValue(argv, "--schema"),
+		frameworkFlag,
 		dbImportFlag: flagValue(argv, "--db-import"),
 		authImportFlag: flagValue(argv, "--auth-import"),
 		contactTableFlag: flagValue(argv, "--contact-table"),

package/{namespace-probe-ouHKZas2.d.mts → namespace-probe-BmxtnOfc.d.mts}

@@ -332,6 +332,22 @@ interface SyncSource {
    * absent from another, and read by the runtime.
    */
   objectType?: string;
+  /**
+   * The `source` label a push carries, when it differs from `entity`.
+   *
+   * Only a projection sets this, and only because a projection entity has no
+   * choice but to carry two names: its entity key doubles as the custom-object
+   * slug and must be kebab-case, while `projection.entityKey` is validated by
+   * `/^[a-z][a-z0-9_]*$/` and rejects hyphens. The server resolves that by
+   * storing the mapping's `sourceTable` as `projection.baseTable` — so a push
+   * labelled with the entity key matched no mapping and every row was dropped,
+   * while `push-schema` reported the mapping created and exited 0.
+   *
+   * Deliberately NOT folded into `entity`: that value is also the cursor-store
+   * key, so redefining it would silently reset the sync cursor of every
+   * existing projection and re-push its whole history.
+   */
+  pushSource?: string;
   /** Set by `fromDrizzle`; lets `doctor` introspect the backing table. */
   [DRIZZLE_META]?: DrizzleSourceMeta;
 }

package/{namespace-probe-lj_0bJrc.d.cts → namespace-probe-C3xMOqWE.d.cts}

@@ -332,6 +332,22 @@ interface SyncSource {
    * absent from another, and read by the runtime.
    */
   objectType?: string;
+  /**
+   * The `source` label a push carries, when it differs from `entity`.
+   *
+   * Only a projection sets this, and only because a projection entity has no
+   * choice but to carry two names: its entity key doubles as the custom-object
+   * slug and must be kebab-case, while `projection.entityKey` is validated by
+   * `/^[a-z][a-z0-9_]*$/` and rejects hyphens. The server resolves that by
+   * storing the mapping's `sourceTable` as `projection.baseTable` — so a push
+   * labelled with the entity key matched no mapping and every row was dropped,
+   * while `push-schema` reported the mapping created and exited 0.
+   *
+   * Deliberately NOT folded into `entity`: that value is also the cursor-store
+   * key, so redefining it would silently reset the sync cursor of every
+   * existing projection and re-push its whole history.
+   */
+  pushSource?: string;
   /** Set by `fromDrizzle`; lets `doctor` introspect the backing table. */
   [DRIZZLE_META]?: DrizzleSourceMeta;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clivly",
-  "version": "0.10.7",
+  "version": "0.10.9",
   "private": false,
   "type": "module",
   "description": "Clivly CLI — scaffold a CRM into your app (clivly init).",