@uql/core 3.3.0 → 3.4.0

package/CHANGELOG.md

@@ -3,9 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-# [3.3.0](https://github.com/rogerpadilla/uql/compare/@uql/core@3.2.0...@uql/core@3.3.0) (2025-12-30)
+# [3.4.0](https://github.com/rogerpadilla/uql/compare/@uql/core@3.3.0...@uql/core@3.4.0) (2025-12-30)
 
-**Note:** Version bump only for package @uql/core
+
+### Features
+
+* add support for Neon, LibSQL, and D1 database queriers, including new querier pools, implementations, tests, and updated documentation. ([aad1df0](https://github.com/rogerpadilla/uql/commit/aad1df0f6bab112b2a0eb0fdffee15dcbc6b0824))
 
 
 

package/README.md

@@ -2,13 +2,12 @@
 
 [![uql maku](assets/logo.svg)](https://uql.app)
 
-[![tests](https://github.com/rogerpadilla/uql/actions/workflows/tests.yml/badge.svg)](https://github.com/rogerpadilla/uql) [![coverage status](https://coveralls.io/repos/rogerpadilla/uql/badge.svg?branch=main)](https://coveralls.io/r/rogerpadilla/uql?branch=main) [![license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/rogerpadilla/uql/blob/main/LICENSE) [![npm version](https://img.shields.io/npm/v/@uql/core.svg)](https://www.npmjs.com/package/@uql/core)
+[![tests](https://github.com/rogerpadilla/uql/actions/workflows/tests.yml/badge.svg)](https://github.com/rogerpadilla/uql) [![Coverage Status](https://coveralls.io/repos/github/rogerpadilla/uql/badge.svg?branch=main)](https://coveralls.io/github/rogerpadilla/uql?branch=main) [![license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/rogerpadilla/uql/blob/main/LICENSE) [![npm version](https://img.shields.io/npm/v/@uql/core.svg)](https://www.npmjs.com/package/@uql/core)
 
-[UQL](https://uql.app) is the [smartest ORM](https://medium.com/@rogerpadillac/in-search-of-the-perfect-orm-e01fcc9bce3d) for TypeScript, it is designed to be fast, safe, and easy to integrate into any application.
+**[UQL](https://uql.app)** is the [smartest ORM](https://medium.com/@rogerpadillac/in-search-of-the-perfect-orm-e01fcc9bce3d) for TypeScript. It is engineered to be **fast**, **safe**, and **universally compatible**.
 
-It can run in Node.js, Browser, React Native, Expo, Electron, Deno, Bun, and many more!
-
-Uses a consistent API for distinct databases, including PostgreSQL, MySQL, MariaDB, and SQLite (inspired by MongoDB glorious syntax).
+- **Runs Everywhere**: Node.js, Bun, Deno, Cloudflare Workers, Electron, React Native, and even the Browser.
+- **Unified API**: A consistent, expressive query interface for PostgreSQL, MySQL, MariaDB, SQLite, LibSQL, Neon, Cloudflare D1, and MongoDB (inspired by its glorious syntax).
 
  
 
@@ -33,7 +32,7 @@ See [this article](https://medium.com/@rogerpadillac/in-search-of-the-perfect-or
 
 - **Type-safe and Context-aware queries**: Squeeze the power of `TypeScript` for auto-completion and validation of operators at any depth, [including relations and their fields](https://www.uql.app/docs/querying-relations).
 - **Context-Object SQL Generation**: Uses a sophisticated `QueryContext` pattern to ensure perfectly indexed placeholders ($1, $2, etc.) and robust SQL fragment management, even in the most complex sub-queries.
-- **Unified API across Databases**: Write once, run anywhere. Seamlessly switch between `PostgreSQL`, `MySQL`, `MariaDB`, `SQLite`, and even `MongoDB`.
+- **Unified API across Databases**: Write once, run anywhere. Seamlessly switch between `PostgreSQL`, `MySQL`, `MariaDB`, `SQLite`, `LibSQL`, `Neon`, `Cloudflare D1`, and even `MongoDB`.
 - **Serializable JSON Syntax**: Queries can be expressed as `100%` valid `JSON`, allowing them to be easily transported from frontend to backend.
 - **Naming Strategies**: Effortlessly translate between TypeScript `CamelCase` and database `snake_case` (or any custom format) with a pluggable system.
 - **Built-in Serialization**: A centralized task queue and `@Serialized()` decorator ensure database operations are thread-safe and race-condition free by default.
@@ -56,12 +55,15 @@ See [this article](https://medium.com/@rogerpadillac/in-search-of-the-perfect-or
 
 2. Install one of the specific adapters for your database:
 
-| Database     | Driver
-| ------------ | ----------------
-| `PostgreSQL` | `pg`
-| `SQLite`     | `better-sqlite3`
-| `MariaDB`    | `mariadb`
-| `MySQL`      | `mysql2`
+| Database | Driver
+| :--- | :---
+| `PostgreSQL` (incl. CockroachDB, YugabyteDB) | `pg`
+| `MySQL` (incl. TiDB, Aurora) | `mysql2`
+| `MariaDB` | `mariadb`
+| `SQLite` | `better-sqlite3`
+| `Cloudflare D1` | `Native Binding`
+| `LibSQL` (Turso) | `@libsql/client`
+| `Neon` (Serverless Postgres) | `@neondatabase/serverless`
 
  
 

package/dist/browser/uql-browser.min.js

@@ -1,108 +1,97 @@
-import sqlstring from 'sqlstring-sqlite';
-import { AbstractSqlDialect } from '../dialect/index.js';
-import { getMeta } from '../entity/index.js';
-import { AbstractSqlQuerier, AbstractQuerierPool } from '../querier/index.js';
+import { isSqlQuerier } from '../type/index.js';
+export { isSqlQuerier } from '../type/index.js';
+import { AbstractDialect } from '../dialect/index.js';
+import { getMeta, getEntities } from '../entity/index.js';
+import { escapeSqlId, getKeys } from '../util/index.js';
+import { readdir, readFile, mkdir, writeFile } from 'node:fs/promises';
+import { join, basename, extname, dirname } from 'node:path';
+import { pathToFileURL } from 'node:url';
 
-class SqliteDialect extends AbstractSqlDialect {
-    constructor(namingStrategy){
-        super(namingStrategy, '`', 'BEGIN TRANSACTION');
-    }
-    addValue(values, value) {
-        if (value instanceof Date) {
-            value = value.getTime();
-        } else if (typeof value === 'boolean') {
-            value = value ? 1 : 0;
-        }
-        return super.addValue(values, value);
-    }
-    compare(ctx, entity, key, val, opts) {
-        if (key === '$text') {
-            const meta = getMeta(entity);
-            const search = val;
-            const fields = search.$fields.map((fKey)=>{
-                const field = meta.fields[fKey];
-                const columnName = this.resolveColumnName(fKey, field);
-                return this.escapeId(columnName);
-            });
-            const tableName = this.resolveTableName(entity, meta);
-            ctx.append(`${this.escapeId(tableName)} MATCH {${fields.join(' ')}} : `);
-            ctx.addValue(search.$value);
-            return;
-        }
-        super.compare(ctx, entity, key, val, opts);
+/**
+ * Abstract base class for SQL schema generation
+ */ class AbstractSchemaGenerator extends AbstractDialect {
+    constructor(namingStrategy, escapeIdChar = '`'){
+        super(namingStrategy), this.escapeIdChar = escapeIdChar;
     }
-    compareFieldOperator(ctx, entity, key, op, val, opts = {}) {
-        super.compareFieldOperator(ctx, entity, key, op, val, opts);
+    /**
+   * Escape an identifier (table name, column name, etc.)
+   */ escapeId(identifier) {
+        return escapeSqlId(identifier, this.escapeIdChar);
     }
-    upsert(ctx, entity, conflictPaths, payload) {
+    generateCreateTable(entity, options = {}) {
         const meta = getMeta(entity);
-        const update = this.getUpsertUpdateAssignments(ctx, meta, conflictPaths, payload, (name)=>`EXCLUDED.${name}`);
-        const keysStr = this.getUpsertConflictPathsStr(meta, conflictPaths);
-        const onConflict = update ? `DO UPDATE SET ${update}` : 'DO NOTHING';
-        this.insert(ctx, entity, payload);
-        ctx.append(` ON CONFLICT (${keysStr}) ${onConflict}`);
-    }
-    escape(value) {
-        return sqlstring.escape(value);
+        const tableName = this.resolveTableName(entity, meta);
+        const columns = this.generateColumnDefinitions(meta);
+        const constraints = this.generateTableConstraints(meta);
+        const ifNotExists = options.ifNotExists ? 'IF NOT EXISTS ' : '';
+        let sql = `CREATE TABLE ${ifNotExists}${this.escapeId(tableName)} (\n`;
+        sql += columns.map((col)=>`  ${col}`).join(',\n');
+        if (constraints.length > 0) {
+            sql += ',\n';
+            sql += constraints.map((c)=>`  ${c}`).join(',\n');
+        }
+        sql += '\n)';
+        sql += this.getTableOptions(meta);
+        sql += ';';
+        return sql;
     }
-}
-
-class SqliteQuerier extends AbstractSqlQuerier {
-    constructor(db, extra){
-        super(new SqliteDialect(extra?.namingStrategy)), this.db = db, this.extra = extra;
-    }
-    async internalAll(query, values) {
-        this.extra?.logger?.(query, values);
-        return this.db.prepare(query).all(values || []);
-    }
-    async internalRun(query, values) {
-        this.extra?.logger?.(query, values);
-        const { changes, lastInsertRowid } = this.db.prepare(query).run(values || []);
-        const firstId = lastInsertRowid ? Number(lastInsertRowid) - (changes - 1) : undefined;
-        const ids = firstId ? Array(changes).fill(firstId).map((i, index)=>i + index) : [];
-        return {
-            changes,
-            ids,
-            firstId
-        };
+    generateDropTable(entity) {
+        const meta = getMeta(entity);
+        const tableName = this.resolveTableName(entity, meta);
+        return `DROP TABLE IF EXISTS ${this.escapeId(tableName)};`;
     }
-    async internalRelease() {
-        if (this.hasOpenTransaction) {
-            throw TypeError('pending transaction');
+    generateAlterTable(diff) {
+        const statements = [];
+        const tableName = this.escapeId(diff.tableName);
+        // Add new columns
+        if (diff.columnsToAdd?.length) {
+            for (const column of diff.columnsToAdd){
+                const colDef = this.generateColumnDefinitionFromSchema(column);
+                statements.push(`ALTER TABLE ${tableName} ADD COLUMN ${colDef};`);
+            }
         }
-    // no-op
-    }
-}
-
-class Sqlite3QuerierPool extends AbstractQuerierPool {
-    constructor(filename, opts, extra){
-        super('sqlite', extra), this.filename = filename, this.opts = opts;
-    }
-    async getQuerier() {
-        if (!this.querier) {
-            let db;
-            if (typeof Bun !== 'undefined') {
-                const { Database } = await import('bun:sqlite');
-                db = new Database(this.filename, this.opts);
-                db.run('PRAGMA journal_mode = WAL');
-            } else {
-                const { default: Database } = await import('better-sqlite3');
-                db = new Database(this.filename, this.opts);
-                db.pragma('journal_mode = WAL');
+        // Alter existing columns
+        if (diff.columnsToAlter?.length) {
+            for (const { to } of diff.columnsToAlter){
+                const colDef = this.generateColumnDefinitionFromSchema(to);
+                const colStatements = this.generateAlterColumnStatements(diff.tableName, to, colDef);
+                statements.push(...colStatements);
+            }
+        }
+        // Drop columns
+        if (diff.columnsToDrop?.length) {
+            for (const columnName of diff.columnsToDrop){
+                statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.escapeId(columnName)};`);
             }
-            this.querier = new SqliteQuerier(db, this.extra);
         }
-        return this.querier;
+        // Add indexes
+        if (diff.indexesToAdd?.length) {
+            for (const index of diff.indexesToAdd){
+                statements.push(this.generateCreateIndex(diff.tableName, index));
+            }
+        }
+        // Drop indexes
+        if (diff.indexesToDrop?.length) {
+            for (const indexName of diff.indexesToDrop){
+                statements.push(this.generateDropIndex(diff.tableName, indexName));
+            }
+        }
+        return statements;
     }
-    async end() {
-        await this.querier.db.close();
-        delete this.querier;
+    generateAlterTableDown(diff) {
+        const statements = [];
+        const tableName = this.escapeId(diff.tableName);
+        // Rollback additions by dropping columns
+        if (diff.columnsToAdd?.length) {
+            for (const column of diff.columnsToAdd){
+                statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.escapeId(column.name)};`);
+            }
+        }
+        return statements;
     }
-}
-
-export { Sqlite3QuerierPool, SqliteDialect, SqliteQuerier };
-//# sourceMappingURL=uql-browser.min.js.map
->this.escapeId(c)).join(', ');
+    generateCreateIndex(tableName, index) {
+        const unique = index.unique ? 'UNIQUE ' : '';
+        const columns = index.columns.map((c)=>this.escapeId(c)).join(', ');
         return `CREATE ${unique}INDEX ${this.escapeId(index.name)} ON ${this.escapeId(tableName)} (${columns});`;
     }
     generateDropIndex(tableName, indexName) {