@uql/core 3.1.2 → 3.1.4

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

@@ -1,97 +1,108 @@
-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';
+import sqlstring from 'sqlstring-sqlite';
+import { AbstractSqlDialect } from '../dialect/index.js';
+import { getMeta } from '../entity/index.js';
+import { AbstractSqlQuerier, AbstractQuerierPool } from '../querier/index.js';
 
-/**
- * Abstract base class for SQL schema generation
- */ class AbstractSchemaGenerator extends AbstractDialect {
-    constructor(namingStrategy, escapeIdChar = '`'){
-        super(namingStrategy), this.escapeIdChar = escapeIdChar;
+class SqliteDialect extends AbstractSqlDialect {
+    constructor(namingStrategy){
+        super(namingStrategy, '`', 'BEGIN TRANSACTION');
     }
-    /**
-   * Escape an identifier (table name, column name, etc.)
-   */ escapeId(identifier) {
-        return escapeSqlId(identifier, this.escapeIdChar);
+    addValue(values, value) {
+        if (value instanceof Date) {
+            value = value.getTime();
+        } else if (typeof value === 'boolean') {
+            value = value ? 1 : 0;
+        }
+        return super.addValue(values, value);
     }
-    generateCreateTable(entity, options = {}) {
-        const meta = getMeta(entity);
-        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;
+    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);
     }
-    generateDropTable(entity) {
+    compareFieldOperator(ctx, entity, key, op, val, opts = {}) {
+        super.compareFieldOperator(ctx, entity, key, op, val, opts);
+    }
+    upsert(ctx, entity, conflictPaths, payload) {
         const meta = getMeta(entity);
-        const tableName = this.resolveTableName(entity, meta);
-        return `DROP TABLE IF EXISTS ${this.escapeId(tableName)};`;
+        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}`);
     }
-    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};`);
-            }
-        }
-        // 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)};`);
-            }
-        }
-        // 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));
-            }
+    escape(value) {
+        return sqlstring.escape(value);
+    }
+}
+
+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
+        };
+    }
+    async internalRelease() {
+        if (this.hasOpenTransaction) {
+            throw TypeError('pending transaction');
         }
-        return statements;
+    // no-op
     }
-    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)};`);
+}
+
+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');
             }
+            this.querier = new SqliteQuerier(db, this.extra);
         }
-        return statements;
+        return this.querier;
     }
-    generateCreateIndex(tableName, index) {
-        const unique = index.unique ? 'UNIQUE ' : '';
-        const columns = index.columns.map((c)=>this.escapeId(c)).join(', ');
+    async end() {
+        await this.querier.db.close();
+        delete this.querier;
+    }
+}
+
+export { Sqlite3QuerierPool, SqliteDialect, SqliteQuerier };
+//# sourceMappingURL=uql-browser.min.js.map
+>this.escapeId(c)).join(', ');
         return `CREATE ${unique}INDEX ${this.escapeId(index.name)} ON ${this.escapeId(tableName)} (${columns});`;
     }
     generateDropIndex(tableName, indexName) {