@human-synthesis/norns 0.0.10 → 0.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@human-synthesis/norns",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "Norns — SvelteKit with Civet, Pug, and the .n / .civet / .c file extensions",
   "license": "MIT",
   "author": "Daniel Teodoroiu (https://humansynthesis.ai)",

package/src/auto-import.js

@@ -653,12 +653,6 @@ function renderImports(entries) {
  *   and excluded from auto-import — forcing an explicit import to disambiguate.
  *
  *   Default `[]` (off; explicit imports for service-layer code).
- * @param {string[] | false} [options.exportDirs]
- *   DEPRECATED. Equivalent to `exportGlobs: dirs.map(d => '${d}/**\/*.{c,civet,js}')`,
- *   which scans every file under those dirs. Path-scoping is still applied,
- *   so server exports won't leak into client files — but the broad scan
- *   surfaces every internal export as a potential auto-import. Migrate to
- *   `exportGlobs: ['src/lib/**\/public.c']` for an intentional API surface.
  * @param {string[]} [options.exportExtensions]
  *   File extensions accepted for exports (defence-in-depth on top of the
  *   glob). Default `['.c', '.civet', '.js']` — `.ts` excluded because
@@ -667,8 +661,8 @@ function renderImports(entries) {
  * @param {string} [options.libAlias]  Default `'$lib'`.
  * @param {string} [options.root]      Default `process.cwd()`.
  * @param {(msg: string) => void} [options.log]
- *   Channel for conflict / deprecation warnings. Default `console.warn`.
- *   Tests pass a stub to assert behavior without polluting output.
+ *   Channel for conflict warnings. Default `console.warn`. Tests pass a
+ *   stub to assert behavior without polluting output.
  */
 export function nornsAutoImport(options = {}) {
 	const root = options.root ?? process.cwd();
@@ -682,23 +676,8 @@ export function nornsAutoImport(options = {}) {
 	const componentSpecs = options.components ?? null;
 	const log = options.log ?? console.warn;
 
-	// Build the effective glob list. `exportGlobs` is the new API;
-	// `exportDirs` is shimmed in for backward compatibility with a one-time
-	// deprecation notice per init.
-	const explicitGlobs =
+	const effectiveGlobs =
 		options.exportGlobs === false || options.exportGlobs == null ? [] : options.exportGlobs;
-	const legacyDirs =
-		options.exportDirs === false || options.exportDirs == null ? [] : options.exportDirs;
-	let effectiveGlobs = [...explicitGlobs];
-	if (legacyDirs.length > 0) {
-		log(
-			'[norns-auto-import] `exportDirs` is deprecated. Migrate to `exportGlobs`, e.g. ' +
-				"`exportGlobs: ['src/lib/**/public.c']` — barrel-file scope is the safe default."
-		);
-		effectiveGlobs = effectiveGlobs.concat(
-			legacyDirs.map((d) => `${d.replace(/\\/g, '/').replace(/\/+$/, '')}/**/*.{c,civet,js}`)
-		);
-	}
 
 	const components =
 		componentDirs.length === 0

package/src/migrate.js

@@ -10,9 +10,11 @@
  * tooling (this CLI, wrangler for D1) reads. Keeping them out of `src/lib`
  * also keeps SvelteKit's bundler from ever trying to ship them.
  *
- * v1 supports SQLite via `better-sqlite3`. Postgres/libSQL come later;
- * Cloudflare D1 is intentionally out of scope here — use
- * `wrangler d1 migrations apply <db>` for D1 deploys.
+ * v1 supports SQLite only. Backend selection is runtime-detected:
+ *   - Under Bun: built-in `bun:sqlite` (no native build, works on Alpine).
+ *   - Under Node: `better-sqlite3` (must be installed in the consumer app).
+ * Postgres/libSQL come later; Cloudflare D1 is intentionally out of scope
+ * here — use `wrangler d1 migrations apply <db>` for D1 deploys.
  */
 
 import { existsSync, readdirSync, statSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
@@ -115,11 +117,21 @@ export function resolveDatabaseUrl(cwd) {
 }
 
 /**
- * Open a better-sqlite3 db at `path` and ensure the migration tracking table
- * exists.
+ * Open a SQLite db at `path` and ensure the migration tracking table exists.
+ *
+ * Backend is runtime-selected: `bun:sqlite` under Bun (no native build,
+ * works on Alpine where `better-sqlite3`'s N-API binding fails to load
+ * against Bun's V8 compat layer), `better-sqlite3` under Node.
+ *
+ * The returned object exposes the better-sqlite3 surface used by the
+ * migration code (`pragma`, `exec`, `prepare(...).all/get/run`,
+ * `transaction`, `close`). Under Bun a minimal `pragma()` shim is grafted
+ * on — bun:sqlite has no built-in `pragma` method, but `exec('PRAGMA …')`
+ * is equivalent for the writes the migrate code performs.
  *
  * @param {string} cwd directory whose `package.json` is used to resolve
  *                     better-sqlite3 from the consumer's node_modules
+ *                     (only relevant under Node)
  * @param {string} path SQLite file path
  * @param {{ requireFrom?: string | URL }} [opts] override the require base
  *                                                (used by tests)
@@ -127,6 +139,32 @@ export function resolveDatabaseUrl(cwd) {
  */
 export function openSqliteDb(cwd, path, opts = {}) {
 	mkdirSync(dirname(path), { recursive: true });
+	const db = openRawSqlite(cwd, path, opts);
+	db.pragma('journal_mode = WAL');
+	db.exec(`CREATE TABLE IF NOT EXISTS ${MIGRATION_TABLE} (
+		id TEXT PRIMARY KEY,
+		applied_at INTEGER NOT NULL
+	)`);
+	return db;
+}
+
+/**
+ * @param {string} cwd
+ * @param {string} path
+ * @param {{ requireFrom?: string | URL }} opts
+ * @returns {any}
+ */
+function openRawSqlite(cwd, path, opts) {
+	if (typeof Bun !== 'undefined') {
+		const r = createRequire(import.meta.url);
+		const { Database } = r('bun:sqlite');
+		const db = new Database(path);
+		// bun:sqlite has no `pragma()` method. Norns calls it only with
+		// write-style statements (`'journal_mode = WAL'`, `'foreign_keys = ON'`),
+		// for which `exec('PRAGMA …')` is the documented equivalent.
+		db.pragma = (stmt) => db.exec('PRAGMA ' + stmt);
+		return db;
+	}
 	const require = createRequire(opts.requireFrom ?? join(cwd, 'package.json'));
 	let Database;
 	try {
@@ -136,13 +174,7 @@ export function openSqliteDb(cwd, path, opts = {}) {
 			'norns migrate: `better-sqlite3` is not installed in this app. Run: bun add better-sqlite3'
 		);
 	}
-	const db = new Database(path);
-	db.pragma('journal_mode = WAL');
-	db.exec(`CREATE TABLE IF NOT EXISTS ${MIGRATION_TABLE} (
-		id TEXT PRIMARY KEY,
-		applied_at INTEGER NOT NULL
-	)`);
-	return db;
+	return new Database(path);
 }
 
 /**

package/src/server/db.js

@@ -56,13 +56,31 @@ function importDynamic(mod) {
  */
 
 /**
- * Open a Drizzle instance backed by `better-sqlite3`.
+ * Open a Drizzle instance backed by SQLite.
+ *
+ * Backend is runtime-selected: `bun:sqlite` + `drizzle-orm/bun-sqlite` under
+ * Bun (built-in, no native build, works on Alpine), `better-sqlite3` +
+ * `drizzle-orm/better-sqlite3` under Node. The function name keeps the
+ * `betterSqlite` alias for backward compatibility — what actually gets
+ * loaded depends on the runtime.
  *
  * @param {string} path SQLite file path (e.g. `data/notes.db`)
  * @param {BetterSqliteOptions} [opts]
  * @returns {Promise<any>}
  */
 export async function betterSqlite(path, opts = {}) {
+	if (typeof Bun !== 'undefined') {
+		const [{ Database }, { drizzle }] = await Promise.all([
+			importDynamic('bun:sqlite'),
+			importDynamic('drizzle-orm/bun-sqlite')
+		]);
+		const sqlite = new Database(path, opts.connection);
+		if (opts.pragma) {
+			// bun:sqlite has no `pragma()` method — use `exec('PRAGMA …')`.
+			for (const p of opts.pragma) sqlite.exec('PRAGMA ' + p);
+		}
+		return drizzle(sqlite, opts.drizzle);
+	}
 	const [{ default: Database }, { drizzle }] = await Promise.all([
 		importDynamic('better-sqlite3'),
 		importDynamic('drizzle-orm/better-sqlite3')