tina4-nodejs 3.8.4 → 3.8.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tina4-nodejs",
-  "version": "3.8.4",
+  "version": "3.8.5",
   "type": "module",
   "description": "This is not a framework. Tina4 for Node.js/TypeScript — zero deps, 38 built-in features.",
   "keywords": ["tina4", "framework", "web", "api", "orm", "graphql", "websocket", "typescript"],
@@ -49,9 +49,7 @@
   "engines": {
     "node": ">=20.0.0"
   },
-  "dependencies": {
-    "better-sqlite3": "^11.0.0"
-  },
+  "dependencies": {},
   "devDependencies": {
     "typescript": "^5.7.0",
     "tsx": "^4.19.0",

package/packages/core/src/sessionHandlers/databaseHandler.ts

@@ -39,18 +39,9 @@ export class DatabaseSessionHandler implements SessionHandler {
   constructor(config?: DatabaseSessionConfig) {
     const dbPath = config?.dbPath ?? this.resolveDbPath();
 
-    let Database: any;
-    try {
-      Database = _require("better-sqlite3");
-    } catch {
-      throw new Error(
-        "DatabaseSessionHandler requires 'better-sqlite3'. " +
-        "Install it with: npm install better-sqlite3"
-      );
-    }
-
-    this.db = new Database(dbPath);
-    this.db.pragma("journal_mode = WAL");
+    const { DatabaseSync } = require("node:sqlite");
+    this.db = new DatabaseSync(dbPath);
+    this.db.exec("PRAGMA journal_mode = WAL");
   }
 
   /**

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

@@ -1,19 +1,19 @@
-import Database from "better-sqlite3";
+import { DatabaseSync } from "node:sqlite";
 import { mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 import type { DatabaseAdapter, DatabaseResult, ColumnInfo, FieldDefinition } from "../types.js";
 
 export class SQLiteAdapter implements DatabaseAdapter {
-  private db: Database.Database;
+  private db: DatabaseSync;
   private _lastInsertId: number | bigint | null = null;
 
   constructor(dbPath: string) {
-    // Create directory if needed
-    mkdirSync(dirname(dbPath), { recursive: true });
-
-    this.db = new Database(dbPath);
-    this.db.pragma("journal_mode = WAL");
-    this.db.pragma("foreign_keys = ON");
+    if (dbPath !== ":memory:") {
+      mkdirSync(dirname(dbPath), { recursive: true });
+    }
+    this.db = new DatabaseSync(dbPath);
+    this.db.exec("PRAGMA journal_mode = WAL");
+    this.db.exec("PRAGMA foreign_keys = ON");
   }
 
   execute(sql: string, params?: unknown[]): unknown {
@@ -30,8 +30,9 @@ export class SQLiteAdapter implements DatabaseAdapter {
     let totalAffected = 0;
     let lastId: number | bigint | undefined;
 
-    const runMany = this.db.transaction((rows: unknown[][]) => {
-      for (const params of rows) {
+    this.db.exec("BEGIN TRANSACTION");
+    try {
+      for (const params of paramsList) {
         const result = stmt.run(...params);
         totalAffected += result.changes;
         if (result.lastInsertRowid) {
@@ -39,9 +40,12 @@ export class SQLiteAdapter implements DatabaseAdapter {
           this._lastInsertId = result.lastInsertRowid;
         }
       }
-    });
+      this.db.exec("COMMIT");
+    } catch (e) {
+      this.db.exec("ROLLBACK");
+      throw e;
+    }
 
-    runMany(paramsList);
     return { totalAffected, lastInsertId: lastId };
   }
 
@@ -68,7 +72,6 @@ export class SQLiteAdapter implements DatabaseAdapter {
   }
 
   insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): DatabaseResult {
-    // Handle list of rows — batch insert
     if (Array.isArray(data)) {
       if (data.length === 0) return { success: true, rowsAffected: 0 };
       const keys = Object.keys(data[0]);
@@ -87,17 +90,9 @@ export class SQLiteAdapter implements DatabaseAdapter {
     try {
       const result = this.db.prepare(sql).run(...values);
       this._lastInsertId = result.lastInsertRowid;
-      return {
-        success: true,
-        rowsAffected: result.changes,
-        lastInsertId: result.lastInsertRowid,
-      };
+      return { success: true, rowsAffected: result.changes, lastInsertId: result.lastInsertRowid };
     } catch (e) {
-      return {
-        success: false,
-        rowsAffected: 0,
-        error: (e as Error).message,
-      };
+      return { success: false, rowsAffected: 0, error: (e as Error).message };
     }
   }
 
@@ -116,7 +111,6 @@ export class SQLiteAdapter implements DatabaseAdapter {
   }
 
   delete(table: string, filter: Record<string, unknown> | string | Record<string, unknown>[]): DatabaseResult {
-    // Array of objects — delete each row
     if (Array.isArray(filter)) {
       let totalAffected = 0;
       for (const row of filter) {
@@ -126,7 +120,6 @@ export class SQLiteAdapter implements DatabaseAdapter {
       return { success: true, rowsAffected: totalAffected };
     }
 
-    // String filter — raw WHERE clause
     if (typeof filter === "string") {
       const sql = filter ? `DELETE FROM "${table}" WHERE ${filter}` : `DELETE FROM "${table}"`;
       try {
@@ -137,7 +130,6 @@ export class SQLiteAdapter implements DatabaseAdapter {
       }
     }
 
-    // Object filter — build WHERE from keys
     const whereClauses = Object.keys(filter).map((k) => `"${k}" = ?`).join(" AND ");
     const sql = `DELETE FROM "${table}" WHERE ${whereClauses}`;
     const values = Object.values(filter);
@@ -150,17 +142,9 @@ export class SQLiteAdapter implements DatabaseAdapter {
     }
   }
 
-  startTransaction(): void {
-    this.db.exec("BEGIN TRANSACTION");
-  }
-
-  commit(): void {
-    this.db.exec("COMMIT");
-  }
-
-  rollback(): void {
-    this.db.exec("ROLLBACK");
-  }
+  startTransaction(): void { this.db.exec("BEGIN TRANSACTION"); }
+  commit(): void { this.db.exec("COMMIT"); }
+  rollback(): void { this.db.exec("ROLLBACK"); }
 
   tables(): string[] {
     const rows = this.query<{ name: string }>(
@@ -171,95 +155,57 @@ export class SQLiteAdapter implements DatabaseAdapter {
 
   columns(table: string): ColumnInfo[] {
     const rows = this.db.prepare(`PRAGMA table_info("${table}")`).all() as Array<{
-      name: string;
-      type: string;
-      notnull: number;
-      dflt_value: unknown;
-      pk: number;
+      name: string; type: string; notnull: number; dflt_value: unknown; pk: number;
     }>;
     return rows.map((r) => ({
-      name: r.name,
-      type: r.type,
-      nullable: r.notnull === 0,
-      default: r.dflt_value,
-      primaryKey: r.pk === 1,
+      name: r.name, type: r.type, nullable: r.notnull === 0, default: r.dflt_value, primaryKey: r.pk === 1,
     }));
   }
 
-  lastInsertId(): number | bigint | null {
-    return this._lastInsertId;
-  }
-
-  close(): void {
-    this.db.close();
-  }
+  lastInsertId(): number | bigint | null { return this._lastInsertId; }
+  close(): void { this.db.close(); }
 
   tableExists(name: string): boolean {
-    const result = this.db
-      .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?")
-      .get(name);
+    const result = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(name);
     return !!result;
   }
 
   createTable(name: string, columns: Record<string, FieldDefinition>): void {
     const colDefs: string[] = [];
-
     for (const [colName, def] of Object.entries(columns)) {
       const sqlType = fieldTypeToSQLite(def.type);
       const parts = [`"${colName}" ${sqlType}`];
-
       if (def.primaryKey) parts.push("PRIMARY KEY");
       if (def.autoIncrement) parts.push("AUTOINCREMENT");
       if (def.required && !def.primaryKey) parts.push("NOT NULL");
-      if (def.default !== undefined && def.default !== "now") {
-        parts.push(`DEFAULT ${sqlDefault(def.default)}`);
-      }
-      if (def.default === "now") {
-        parts.push("DEFAULT CURRENT_TIMESTAMP");
-      }
-
+      if (def.default !== undefined && def.default !== "now") parts.push(`DEFAULT ${sqlDefault(def.default)}`);
+      if (def.default === "now") parts.push("DEFAULT CURRENT_TIMESTAMP");
       colDefs.push(parts.join(" "));
     }
-
-    const sql = `CREATE TABLE IF NOT EXISTS "${name}" (${colDefs.join(", ")})`;
-    this.db.exec(sql);
+    this.db.exec(`CREATE TABLE IF NOT EXISTS "${name}" (${colDefs.join(", ")})`);
   }
 
   getTableColumns(name: string): Array<{ name: string; type: string }> {
-    return this.db.prepare(`PRAGMA table_info("${name}")`).all() as Array<{
-      name: string;
-      type: string;
-    }>;
+    return this.db.prepare(`PRAGMA table_info("${name}")`).all() as Array<{ name: string; type: string }>;
   }
 
   addColumn(table: string, colName: string, def: FieldDefinition): void {
     const sqlType = fieldTypeToSQLite(def.type);
     let sql = `ALTER TABLE "${table}" ADD COLUMN "${colName}" ${sqlType}`;
-    if (def.default !== undefined && def.default !== "now") {
-      sql += ` DEFAULT ${sqlDefault(def.default)}`;
-    } else if (def.default === "now") {
-      sql += " DEFAULT CURRENT_TIMESTAMP";
-    }
+    if (def.default !== undefined && def.default !== "now") sql += ` DEFAULT ${sqlDefault(def.default)}`;
+    else if (def.default === "now") sql += " DEFAULT CURRENT_TIMESTAMP";
     this.db.exec(sql);
   }
 }
 
 function fieldTypeToSQLite(type: string): string {
   switch (type) {
-    case "integer":
-      return "INTEGER";
-    case "number":
-    case "numeric":
-      return "REAL";
-    case "boolean":
-      return "INTEGER";
-    case "datetime":
-      return "TEXT";
-    case "text":
-      return "TEXT";
-    case "string":
-    default:
-      return "TEXT";
+    case "integer": return "INTEGER";
+    case "number": case "numeric": return "REAL";
+    case "boolean": return "INTEGER";
+    case "datetime": return "TEXT";
+    case "text": return "TEXT";
+    case "string": default: return "TEXT";
   }
 }