tina4-nodejs 3.11.10 → 3.11.12

package/package.json

@@ -3,7 +3,7 @@
 
 
 
-  "version": "3.11.10",
+  "version": "3.11.12",
 
   "type": "module",
   "description": "Tina4 for Node.js/TypeScript — 54 built-in features, zero dependencies",

package/packages/orm/src/adapters/sqlite.ts

@@ -1,17 +1,48 @@
 import { DatabaseSync } from "node:sqlite";
 import { mkdirSync } from "node:fs";
-import { dirname } from "node:path";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 import type { DatabaseAdapter, DatabaseResult, ColumnInfo, FieldDefinition } from "../types.js";
 
+/**
+ * Resolve a SQLite path argument against the project root (cwd).
+ *
+ * Matches the tina4-python + tina4-php convention:
+ *   ":memory:"         → passthrough
+ *   "data/app.db"      → {cwd}/data/app.db  (auto-mkdir under cwd)
+ *   "/abs/app.db"      → /abs/app.db        (NO auto-mkdir; user's responsibility)
+ *   "C:/Users/app.db"  → C:/Users/app.db    (NO auto-mkdir)
+ *
+ * Never mkdir a directory that isn't a descendant of cwd — that was the
+ * root cause of the `EROFS: read-only file system, mkdir '/data'` crash
+ * reported on macOS.
+ */
+function resolveSqlitePath(dbPath: string): string {
+  if (dbPath === ":memory:") return dbPath;
+
+  let path = dbPath;
+  if (!isAbsolute(path)) {
+    path = join(process.cwd(), path);
+    // Auto-mkdir is safe here — we know the parent is under cwd
+    mkdirSync(dirname(path), { recursive: true });
+  } else {
+    // Absolute path. Only auto-mkdir if it's a descendant of cwd.
+    const cwd = resolve(process.cwd());
+    const abs = resolve(path);
+    if (abs.startsWith(cwd + "/") || abs === cwd) {
+      mkdirSync(dirname(abs), { recursive: true });
+    }
+    // Otherwise, trust the user — don't touch the filesystem.
+  }
+  return path;
+}
+
 export class SQLiteAdapter implements DatabaseAdapter {
   private db: DatabaseSync;
   private _lastInsertId: number | bigint | null = null;
 
   constructor(dbPath: string) {
-    if (dbPath !== ":memory:") {
-      mkdirSync(dirname(dbPath), { recursive: true });
-    }
-    this.db = new DatabaseSync(dbPath);
+    const resolved = resolveSqlitePath(dbPath);
+    this.db = new DatabaseSync(resolved);
     this.db.exec("PRAGMA journal_mode = WAL");
     this.db.exec("PRAGMA foreign_keys = ON");
   }

package/packages/orm/src/database.ts

@@ -92,18 +92,31 @@ export interface ParsedDatabaseUrl {
 export function parseDatabaseUrl(url: string, username?: string, password?: string): ParsedDatabaseUrl {
   let result: ParsedDatabaseUrl;
 
-  // Handle sqlite:// separately because URL class mangles the path
-  if (url.startsWith("sqlite:///")) {
-    // sqlite:///absolute/path — three slashes means absolute
-    let path = url.slice("sqlite://".length);
-    // Windows: sqlite:///C:/Users/app.db → /C:/Users/app.db after slicing.
-    // The leading / before the drive letter must be removed.
-    if (/^\/[A-Za-z]:/.test(path)) {
-      path = path.slice(1);
-    }
-    result = { type: "sqlite", path };
+  // Handle sqlite:// separately because URL class mangles the path.
+  //
+  // Convention (matches tina4-python, tina4-php, and the docs):
+  //   sqlite::memory:              → in-memory
+  //   sqlite:///:memory:           → in-memory (URL form)
+  //   sqlite:///app.db             → ./app.db (relative to cwd)
+  //   sqlite:///data/app.db        → ./data/app.db (relative)
+  //   sqlite:////absolute/app.db   → /absolute/app.db (absolute)
+  //   sqlite:///C:/Users/app.db    → C:/Users/app.db (Windows absolute)
+  if (url === "sqlite::memory:" || url === "sqlite:///:memory:") {
+    result = { type: "sqlite", path: ":memory:" };
+  } else if (url.startsWith("sqlite:///")) {
+    // Strip the "sqlite://" prefix (leaving one "/" + path)
+    let rest = url.slice("sqlite://".length); // e.g. "/data/app.db" or "//abs/app.db" or "/C:/Users/..."
+    // Drop exactly one leading "/"
+    if (rest.startsWith("/")) rest = rest.slice(1);
+    // Windows absolute: C:/Users/app.db or C:\...
+    const isWindowsAbs = /^[A-Za-z]:[\/\\]/.test(rest);
+    // Unix absolute: still starts with "/" after the strip (four-slash URL form)
+    const isUnixAbs = rest.startsWith("/");
+    result = { type: "sqlite", path: isWindowsAbs || isUnixAbs ? rest : rest };
+    // Relative paths are resolved against cwd by the SQLite adapter at connect time;
+    // keep the string as-is here so tests can inspect the raw form.
   } else if (url.startsWith("sqlite://")) {
-    // sqlite://./relative or sqlite://relative
+    // sqlite://./relative or sqlite://relative — legacy two-slash form
     const path = url.slice("sqlite://".length);
     result = { type: "sqlite", path };
   } else if (url.startsWith("mssql://") || url.startsWith("sqlserver://")) {