orange-orm 4.6.0 → 4.7.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orange-orm",
-  "version": "4.6.0",
+  "version": "4.7.0-beta.0",
   "main": "./src/index.js",
   "module": "./dist/index.mjs",
   "browser": "./dist/index.browser.mjs",
@@ -62,10 +62,10 @@
     "beta": "npm publish --tag beta"
   },
   "dependencies": {
+    "@cloudflare/workers-types": "^4.20241106.0",
     "@lroal/on-change": "^4.0.2",
     "@tediousjs/connection-string": "^0.4.1",
     "@types/express": "^4.17.13",
-    "@cloudflare/workers-types": "^4.20241106.0",
     "@types/oracledb": "^6.0.4",
     "@types/tedious": "^4.0.14",
     "ajv": "^6.10.2",
@@ -85,7 +85,8 @@
     "pg-native": "^3.0.0",
     "pg-query-stream": "^3.3.2",
     "sqlite3": "^5.0.2",
-    "tedious": "^15.1.2 || ^16.0.0 || ^18.1.0"
+    "tedious": "^15.1.2 || ^16.0.0 || ^18.1.0",
+    "@electric-sql/pglite": "^0.3.0"
   },
   "peerDependenciesMeta": {
     "pg": {
@@ -111,9 +112,13 @@
     },
     "oracledb": {
       "optional": true
+    },
+    "@electric-sql/pglite": {
+      "optional": true
     }
   },
-  "devDependencies": {    
+  "devDependencies": {
+    "@electric-sql/pglite": "^0.3.0",
     "@miniflare/d1": "^2.14.4",
     "@rollup/plugin-commonjs": "^28.0.2",
     "@rollup/plugin-json": "^6.1.0",

package/src/bunPg/newTransaction.js

@@ -1,6 +1,5 @@
 var wrapQuery = require('./wrapQuery');
 var encodeDate = require('../pg/encodeDate');
-var encodeBoolean = require('../pg/encodeBoolean');
 const encodeBinary = require('../nodeSqlite/encodeBinary');
 const decodeBinary = require('../nodeSqlite/decodeBinary');
 var deleteFromSql = require('../pg/deleteFromSql');
@@ -20,7 +19,6 @@ function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 	}
 
 	rdb.engine = 'pg';
-	rdb.encodeBoolean = encodeBoolean;
 	rdb.encodeDate = encodeDate;
 	rdb.encodeBinary = encodeBinary;
 	rdb.decodeBinary = decodeBinary;

package/src/client/clientMap.js

@@ -32,6 +32,7 @@ function map(index, _fn) {
 
 	dbMap.http = (url) => url;
 	dbMap.pg = throwDb;
+	dbMap.pglite = throwDb;
 	dbMap.postgres = throwDb;
 	dbMap.mssql = throwDb;
 	dbMap.mssqlNative = throwDb;
@@ -59,6 +60,7 @@ function map(index, _fn) {
 
 	onFinal.http = (url) => index({ db: url, providers: dbMap });
 	onFinal.pg = () => index({ db: throwDb, providers: dbMap });
+	onFinal.pglite = () => index({ db: throwDb, providers: dbMap });
 	onFinal.postgres = () => index({ db: throwDb, providers: dbMap });
 	onFinal.mssql = () => index({ db: throwDb, providers: dbMap });
 	onFinal.mssqlNative = () => index({ db: throwDb, providers: dbMap });

package/src/client/createProviders.js

@@ -13,6 +13,11 @@ function createProviders(index) {
 			return createPool.bind(null, 'pg');
 		}
 	});
+	Object.defineProperty(dbMap, 'pglite', {
+		get:  function() {
+			return createPool.bind(null, 'pglite');
+		}
+	});
 	Object.defineProperty(dbMap, 'postgres', {
 		get:  function() {
 			return createPool.bind(null, 'pg');
@@ -81,6 +86,9 @@ function negotiateCachedPool(fn, providers) {
 		get pg() {
 			return createPool.bind(null, 'pg');
 		},
+		get pglite() {
+			return createPool.bind(null, 'pglite');
+		},
 		get postgres() {
 			return createPool.bind(null, 'pg');
 		},

package/src/client/index.js

@@ -56,6 +56,7 @@ function rdbClient(options = {}) {
 	client.mssql = onProvider.bind(null, 'mssql');
 	client.mssqlNative = onProvider.bind(null, 'mssqlNative');
 	client.pg = onProvider.bind(null, 'pg');
+	client.pglite = onProvider.bind(null, 'pglite');
 	client.postgres = onProvider.bind(null, 'postgres');
 	client.d1 = onProvider.bind(null, 'd1');
 	client.sqlite = onProvider.bind(null, 'sqlite');

package/src/client/map.js

@@ -41,6 +41,7 @@ function map(index, context, providers, fn) {
 	}
 	context.map = map.bind(null, index, context, providers);
 	context.pg = connect.bind(null, 'pg');
+	context.pglite = connect.bind(null, 'pglite');
 	context.postgres = connect.bind(null, 'pg');
 	context.mssql = connect.bind(null, 'mssql');
 	context.mssqlNative = connect.bind(null, 'mssqlNative');

package/src/index.d.ts

@@ -1,4 +1,5 @@
 import type { Options } from './ajv';
+import type { PGliteOptions } from './pglite.d.ts';
 import type { RequestHandler } from 'express';
 import type { D1Database } from '@cloudflare/workers-types';
 import type { ConnectionConfiguration } from 'tedious';
@@ -13,6 +14,7 @@ declare namespace r {
     function end(): Promise<void>;
     function d1(database: D1Database, options?: PoolOptions): Pool;
     function postgres(connectionString: string, options?: PoolOptions): Pool;
+    function pglite(config?: PGliteOptions | string | undefined, options?: PoolOptions): Pool;
     function sqlite(connectionString: string, options?: PoolOptions): Pool;
     function sap(connectionString: string, options?: PoolOptions): Pool;
     function mssql(connectionConfig: ConnectionConfiguration, options?: PoolOptions): Pool;

package/src/index.js

@@ -6,6 +6,7 @@ const runtimes = require('./runtimes');
 
 let _mySql;
 let _pg;
+let _pglite;
 let _sqlite;
 let _mssqlNative;
 let _sap;
@@ -54,6 +55,13 @@ Object.defineProperty(connectViaPool, 'mySql', {
 		return _mySql;
 	}
 });
+Object.defineProperty(connectViaPool, 'pglite', {
+	get: function() {
+		if (!_pglite)
+			_pglite = require('./pglite/newDatabase');
+		return _pglite;
+	}
+});
 Object.defineProperty(connectViaPool, 'postgres', {
 	get: function() {
 		if (!_pg)

package/src/map.d.ts

@@ -1,4 +1,5 @@
 import type { Options } from './ajv';
+import type { PGliteOptions } from './pglite.d.ts';
 import type { ConnectionConfiguration } from 'tedious';
 import type { D1Database } from '@cloudflare/workers-types';
 import type { PoolAttributes } from 'oracledb';
@@ -32,6 +33,7 @@ type DbConnectable<T> = {
 	http(url: string): MappedDbInstance<T>;
 	d1(database: D1Database): MappedDbInstance<T>;
 	postgres(connectionString: string, options?: PoolOptions): MappedDbInstance<T>;
+	pglite(config?: PGliteOptions| string | undefined, options?: PoolOptions): MappedDbInstance<T>;
 	sqlite(connectionString: string, options?: PoolOptions): MappedDbInstance<T>;
 	sap(connectionString: string, options?: PoolOptions): MappedDbInstance<T>;
 	mssql(connectionConfig: ConnectionConfiguration, options?: PoolOptions): MappedDbInstance<T>;
@@ -63,6 +65,7 @@ interface Connectors {
 	http(url: string): Pool;
 	d1(database: D1Database): Pool;
 	postgres(connectionString: string, options?: PoolOptions): Pool;
+	pglite(config?: PGliteOptions| string | undefined, options?: PoolOptions): Pool;
 	sqlite(connectionString: string, options?: PoolOptions): Pool;
 	sap(connectionString: string, options?: PoolOptions): Pool;
 	mssql(connectionConfig: ConnectionConfiguration, options?: PoolOptions): Pool;

package/src/pglite/newDatabase.js

@@ -0,0 +1,135 @@
+let createDomain = require('../createDomain');
+let newTransaction = require('./newTransaction');
+let _begin = require('../table/begin');
+let commit = require('../table/commit');
+let rollback = require('../table/rollback');
+let newPool = require('./newPool');
+let lock = require('../lock');
+let executeSchema = require('../pg/schema');
+let express = require('../hostExpress');
+let hostLocal = require('../hostLocal');
+let doQuery = require('../query');
+let releaseDbClient = require('../table/releaseDbClient');
+let setSessionSingleton = require('../table/setSessionSingleton');
+
+function newDatabase(connectionString, poolOptions) {
+	var pool;
+	if (!poolOptions)
+		pool = newPool.bind(null, connectionString, poolOptions);
+	else
+		pool = newPool(connectionString, poolOptions);
+
+	let c = { poolFactory: pool, hostLocal, express };
+
+	c.transaction = function(options, fn) {
+		if ((arguments.length === 1) && (typeof options === 'function')) {
+			fn = options;
+			options = undefined;
+		}
+		let domain = createDomain();
+
+		if (fn)
+			return domain.run(runInTransaction);
+		else
+			return domain.run(run);
+
+		async function runInTransaction() {
+			let result;
+			let transaction = newTransaction(domain, pool, options);
+			await new Promise(transaction)
+				.then(begin)
+				.then(negotiateSchema)
+				.then(() => fn(domain))
+				.then((res) => result = res)
+				.then(() => commit(domain))
+				.then(null, (e) => rollback(domain,e));
+			return result;
+		}
+
+		function begin() {
+			return _begin(domain, options);
+		}
+
+		function run() {
+			let p;
+			let transaction = newTransaction(domain, pool, options);
+			p = new Promise(transaction);
+
+			return p.then(begin)
+				.then(negotiateSchema);
+		}
+
+		function negotiateSchema(previous) {
+			let schema = options && options.schema;
+			if (!schema)
+				return previous;
+			return executeSchema(domain, schema);
+		}
+	};
+
+	c.createTransaction = function(options) {
+		let domain = createDomain();
+		let transaction = newTransaction(domain, pool, options);
+		let p = domain.run(() => new Promise(transaction)
+			.then(begin).then(negotiateSchema));
+
+		function run(fn) {
+			return p.then(domain.run.bind(domain, fn));
+		}
+
+		function begin() {
+			return _begin(domain, options);
+		}
+
+		function negotiateSchema(previous) {
+			let schema = options && options.schema;
+			if (!schema)
+				return previous;
+			return executeSchema(domain,schema);
+		}
+
+		run.rollback = rollback.bind(null, domain);
+		run.commit = commit.bind(null, domain);
+
+		return run;
+	};
+
+	c.query = function(query) {
+		let domain = createDomain();
+		let transaction = newTransaction(domain, pool);
+		let p = domain.run(() => new Promise(transaction)
+			.then(() => setSessionSingleton(domain, 'changes', []))
+			.then(() => doQuery(domain, query).then(onResult, onError)));
+		return p;
+
+		function onResult(result) {
+			releaseDbClient(domain);
+			return result;
+		}
+
+		function onError(e) {
+			releaseDbClient(domain);
+			throw e;
+		}
+	};
+
+	c.rollback = rollback;
+	c.commit = commit;
+	c.lock = lock;
+	c.schema = executeSchema;
+
+	c.end = function() {
+		if (poolOptions)
+			return pool.end();
+		else
+			return Promise.resolve();
+	};
+
+	c.accept = function(caller) {
+		caller.visitPg();
+	};
+
+	return c;
+}
+
+module.exports = newDatabase;

package/src/pglite/newPool.js

@@ -0,0 +1,19 @@
+const promisify = require('../promisify');
+const pools = require('../pools');
+const end = require('./pool/end');
+const newPgPool = require('./pool/newPgPool');
+const newId = require('../newId');
+
+function newPool(connectionString, poolOptions) {
+	let pool = newPgPool(connectionString, poolOptions);
+	let id = newId();
+	let boundEnd = end.bind(null, pool, id);
+	let c = {};
+
+	c.connect = pool.connect;
+	c.end = promisify(boundEnd);
+	pools[id] = c;
+	return c;
+}
+
+module.exports = newPool;

package/src/pglite/newTransaction.js

@@ -0,0 +1,83 @@
+var wrapQuery = require('./wrapQuery');
+var encodeDate = require('../pg/encodeDate');
+const encodeBinary = require('../nodeSqlite/encodeBinary');
+const decodeBinary = require('../nodeSqlite/decodeBinary');
+var deleteFromSql = require('../pg/deleteFromSql');
+var selectForUpdateSql = require('../pg/selectForUpdateSql');
+var limitAndOffset = require('../pg/limitAndOffset');
+var formatDateOut = require('../pg/formatDateOut');
+var insertSql = require('../pg/insertSql');
+var insert = require('../pg/insert');
+var quote = require('../pg/quote');
+
+function newResolveTransaction(domain, pool, { readonly = false } = {}) {
+	var rdb = { poolFactory: pool };
+	if (!pool.connect) {
+		pool = pool();
+		rdb.pool = pool;
+	}
+
+	rdb.engine = 'pg';
+	rdb.encodeDate = encodeDate;
+	rdb.encodeBinary = encodeBinary;
+	rdb.decodeBinary = decodeBinary;
+	rdb.formatDateOut = formatDateOut;
+	rdb.deleteFromSql = deleteFromSql;
+	rdb.selectForUpdateSql = selectForUpdateSql;
+	rdb.lastInsertedIsSeparate = false;
+	rdb.insertSql = insertSql;
+	rdb.insert = insert;
+	rdb.multipleStatements = true;
+	rdb.limitAndOffset = limitAndOffset;
+	rdb.accept = function(caller) {
+		caller.visitPg();
+	};
+	rdb.aggregateCount = 0;
+	rdb.quote = quote;
+	rdb.cache = {};
+
+	if (readonly) {
+		rdb.dbClient = {
+			executeQuery: function(query, callback) {
+				pool.connect((err, client, done) => {
+					if (err) {
+						return callback(err);
+					}
+					try {
+						wrapQuery(domain, client)(query, (err, res) => {
+							done();
+							callback(err, res);
+						});
+					} catch (e) {
+						done();
+						callback(e);
+					}
+				});
+			}
+		};
+		domain.rdb = rdb;
+		return (onSuccess) => onSuccess();
+	}
+
+	return function(onSuccess, onError) {
+		pool.connect(onConnected);
+
+		function onConnected(err, client, done) {
+			try {
+				if (err) {
+					onError(err);
+					return;
+				}
+				client.executeQuery = wrapQuery(domain, client);
+				rdb.dbClient = client;
+				rdb.dbClientDone = done;
+				domain.rdb = rdb;
+				onSuccess();
+			} catch (e) {
+				onError(e);
+			}
+		}
+	};
+}
+
+module.exports = newResolveTransaction;

package/src/pglite/pool/end.js

@@ -0,0 +1,14 @@
+var pools = require('../../pools');
+
+function endPool(pgPool, id, done) {
+	pgPool.drain(onDrained);
+
+	function onDrained() {
+		//todo await
+		pgPool.destroyAllNow();
+		delete pools[id];
+		done();
+	}
+}
+
+module.exports = endPool;

package/src/pglite/pool/newPgPool.js

@@ -0,0 +1,96 @@
+/* eslint-disable no-prototype-builtins */
+// Simplified pool creator using URL API and handling search_path param
+
+const log = require('../../table/log');
+const defaults = require('../../poolDefaults');
+const genericPool = require('../../generic-pool');
+let PGlite;
+
+function newPgPool(connectionString, poolOptions = {}) {
+	let { connStr, searchPath } = extractSearchPath(connectionString);
+
+	//@ts-ignore
+	const pool = genericPool.Pool({
+		max: poolOptions.size || poolOptions.poolSize || defaults.poolSize,
+		idleTimeoutMillis: poolOptions.idleTimeout || defaults.poolIdleTimeout,
+		reapIntervalMillis: poolOptions.reapIntervalMillis || defaults.reapIntervalMillis,
+		log: poolOptions.log,
+
+		create: async (cb) => {
+			try {
+				if (!PGlite) ({ PGlite } = await import('@electric-sql/pglite'));
+				const client = connStr === undefined ? new PGlite() : new PGlite(connStr);
+				client.poolCount = 0;
+				await applySearchPath(client, searchPath);
+				cb(null, client);
+			} catch (err) {
+				cb(err, null);
+			}
+		},
+
+		destroy: (client) => {
+			client._destroying = true;
+			client.poolCount = undefined;
+			client.close();
+		},
+	});
+
+	pool.connect = (cb) => {
+		pool.acquire((err, client) => {
+			if (err) return cb(err, null, () => { });
+			client.poolCount++;
+			cb(null, client, (releaseErr) => {
+				releaseErr ? pool.destroy(client) : pool.release(client);
+			});
+		});
+	};
+
+	return pool;
+}
+
+async function applySearchPath(client, searchPath) {
+	if (searchPath) {
+		const sql = `SET search_path TO ${searchPath}`;
+		log.emitQuery({ sql, parameters: [] });
+		await client.exec(sql);
+	}
+}
+
+function extractSearchPath(connectionString) {
+	let connStr = connectionString;
+	let searchPath;
+
+	// Guard: nothing to do
+	if (typeof connectionString !== 'string' || connectionString.length === 0) {
+		return { connStr, searchPath };
+	}
+
+	// Split on the *first* "?" only
+	const qPos = connectionString.indexOf('?');
+	if (qPos === -1) {
+		// No query-string segment
+		return { connStr, searchPath };
+	}
+
+	const pathPart = connectionString.slice(0, qPos);
+	const qsPart = connectionString.slice(qPos + 1);
+
+	// Robust query-string handling via URLSearchParams
+	const params = new URLSearchParams(qsPart);
+
+	const paramName = 'search_path';
+
+	if (paramName) {
+		searchPath = params.get(paramName);
+		params.delete(paramName);
+	}
+
+	// Re-assemble the cleaned connection string
+	const remainingQs = params.toString();
+	connStr = remainingQs ? `${pathPart}?${remainingQs}` : pathPart;
+
+	return { connStr, searchPath };
+}
+
+
+module.exports = newPgPool;

package/src/pglite/wrapQuery.js

@@ -0,0 +1,27 @@
+var log = require('../table/log');
+var replaceParamChar = require('../pg/replaceParamChar');
+
+function wrapQuery(_context, connection) {
+	var runOriginalQuery = connection.query;
+	return runQuery;
+
+	function runQuery(query, onCompleted) {
+		var params = query.parameters;
+		var sql = replaceParamChar(query, params);
+		log.emitQuery({sql, parameters: params});
+		runOriginalQuery.call(connection, sql, params).then((result) => onInnerCompleted(null, result), (e) => onInnerCompleted(e));
+
+		function onInnerCompleted(err, result) {
+			if (err)
+				onCompleted(err);
+			else {
+				if (Array.isArray(result))
+					result = result[result.length-1];
+				onCompleted(null, result.rows);
+			}
+		}
+	}
+
+}
+
+module.exports = wrapQuery;

package/src/pglite.d.ts

@@ -0,0 +1,64 @@
+/* pglite-options.d.ts */
+
+/** Log-level for debug output (0 = silent, 5 = most verbose). */
+export type DebugLevel = 0 | 1 | 2 | 3 | 4 | 5;
+
+/** Function that converts a textual Postgres value to a JS value. */
+export type Parser = (value: string, typeId?: number) => unknown;
+/** Function that converts a JS value to its Postgres text form. */
+export type Serializer = (value: unknown) => string;
+
+/** Per-OID parser override map. */
+export interface ParserOptions {
+  [pgType: number]: Parser;
+}
+/** Per-OID serializer override map. */
+export interface SerializerOptions {
+  [pgType: number]: Serializer;
+}
+
+/** Arbitrary extension registry keyed by namespace. */
+export type Extensions = Record<string, unknown>;
+
+/** Virtual-filesystem interface (sans `init`). */
+export interface Filesystem {
+  syncToFs(relaxedDurability?: boolean): Promise<void>;
+  initialSyncFs(): Promise<void>;
+  dumpTar(
+    dbname: string,
+    compression?: 'none' | 'gzip' | 'auto'
+  ): Promise<File | Blob>;
+  closeFs(): Promise<void>;
+}
+
+/** Construction options for a `PGlite` instance. */
+export interface PGliteOptions<
+  TExtensions extends Extensions = Extensions
+> {
+  /** Directory for database files (e.g. `"idb://mydb"`, `"memory://"`). */
+  dataDir?: string;
+  /** PostgreSQL user name (defaults to `"postgres"`). */
+  username?: string;
+  /** Default database name (defaults to `"postgres"`). */
+  database?: string;
+  /** Custom virtual filesystem implementation. */
+  fs?: Filesystem;
+  /** Debug verbosity; `0` disables all logging. */
+  debug?: DebugLevel;
+  /** If `true`, disables `fsync` for faster but less-durable writes. */
+  relaxedDurability?: boolean;
+  /** Map of extension namespaces → implementations or URLs. */
+  extensions?: TExtensions;
+  /** Pre-seed the cluster with an existing data directory. */
+  loadDataDir?: Blob | File;
+  /** Initial WebAssembly memory size in bytes. */
+  initialMemory?: number;
+  /** Pre-compiled WASM module to reuse instead of fetching the default. */
+  wasmModule?: WebAssembly.Module;
+  /** Pre-bundled filesystem layer to mount at startup. */
+  fsBundle?: Blob | File;
+  /** Override parsers per type-OID. */
+  parsers?: ParserOptions;
+  /** Override serializers per type-OID. */
+  serializers?: SerializerOptions;
+}

package/src/table/column/boolean/newEncode.js

@@ -11,7 +11,7 @@ function _new(column) {
 				return newParam('null');
 			return newParam('\'' + column.dbNull + '\'');
 		}
-		var encodeCore = getSessionSingleton(context, 'encodeBoolean');
+		var encodeCore = getSessionSingleton(context, 'encodeBoolean') || encodeDefault;
 
 
 		return newParam('?', [encodeCore(value)]);
@@ -24,14 +24,14 @@ function _new(column) {
 				return 'null';
 			return '\'' + column.dbNull + '\'';
 		}
-		var encodeCore = getSessionSingleton(context, 'encodeBoolean');
+		var encodeCore = getSessionSingleton(context, 'encodeBoolean') || encodeDefault;
 
 
 		return encodeCore(value);
 	};
 
 	encode.direct = function(context, value) {
-		var encodeCore = getSessionSingleton(context, 'encodeBoolean');
+		var encodeCore = getSessionSingleton(context, 'encodeBoolean') || encodeDefault;
 
 		return encodeCore(value);
 	};
@@ -39,4 +39,8 @@ function _new(column) {
 	return encode;
 }
 
+function encodeDefault(value) {
+	return value;
+}
+
 module.exports = _new;

package/src/table/column/json/newEncode.js

@@ -11,7 +11,7 @@ function _new(column) {
 				return newPara('null');
 			return newPara('\'' + column.dbNull + '\'');
 		}
-		var encodeCore = getSessionSingleton(context, 'encodeJSON');
+		var encodeCore = getSessionSingleton(context, 'encodeJSON') || ((v) => v);
 
 		if (encodeCore) {
 			value = encodeCore(value);
@@ -27,7 +27,7 @@ function _new(column) {
 				return 'null';
 			return '\'' + column.dbNull + '\'';
 		}
-		var encodeCore = getSessionSingleton(context, 'encodeJSON');
+		var encodeCore = getSessionSingleton(context, 'encodeJSON') || ((v) => v);
 
 		if (encodeCore) {
 			value = encodeCore(value);
@@ -36,7 +36,7 @@ function _new(column) {
 	};
 
 	encode.direct = function(context, value) {
-		var encodeCore = getSessionSingleton(context, 'encodeJSON');
+		var encodeCore = getSessionSingleton(context, 'encodeJSON') || ((v) => v);
 
 		if (encodeCore) {
 			value = encodeCore(value);