orange-orm 4.10.0-beta.0 → 5.0.0-beta.0

package/README.md

@@ -51,7 +51,7 @@ Watch the [tutorial video on YouTube](https://youtu.be/1IwwjPr2lMs)
 ![Relations diagram](./docs/diagram.svg)  
 
 <sub>📄 map.ts</sub>
-```javascript
+```ts
 import orange from 'orange-orm';
 
 const map = orange.map(x => ({
@@ -88,7 +88,7 @@ const map = orange.map(x => ({
     street: column('street').string(),
     postalCode: column('postalCode').string(),
     postalPlace: column('postalPlace').string(),
-    countryCode: column('countryCode').string(),
+    countryCode: column('countryCode').string().enum(['NO', 'SE', 'DK', 'FI', 'IS', 'DE', 'FR', 'NL', 'ES', 'IT']),
   }))
 
 })).map(x => ({
@@ -106,7 +106,7 @@ export default map;
 ```  
 <sub>📄 update.ts</sub>
 
-```javascript
+```ts
 import map from './map';
 const db = map.sqlite('demo.db');
 
@@ -127,7 +127,7 @@ async function updateRow() {
 ```
 <sub>📄 filter.ts</sub>
 
-```javascript
+```ts
 import map from './map';
 const db = map.sqlite('demo.db');
 
@@ -157,7 +157,8 @@ Each column within your database table is designated by using the <strong><i>col
 Relationships between tables can also be outlined. By using methods like <strong><i>hasOne</i></strong>, <strong><i>hasMany</i></strong>, and <strong><i>references</i></strong>, you can establish connections that reflect the relationships in your data schema. In the example below, an 'order' is linked to a 'customer' reference, a 'deliveryAddress', and multiple 'lines'. The hasMany and hasOne relations represents ownership - the tables 'deliveryAddress' and 'orderLine' are owned by the 'order' table, and therefore, they contain the 'orderId' column referring to their parent table, which is 'order'. The similar relationship exists between orderLine and package - hence the packages are owned by the orderLine. Conversely, the customer table is independent and can exist without any knowledge of the 'order' table. Therefore we say that the order table <i>references</i> the customer table - necessitating the existence of a 'customerId' column in the 'order' table.</p>
 
 <sub>📄 map.ts</sub>
-```javascript
+
+```ts
 import orange from 'orange-orm';
 
 const map = orange.map(x => ({
@@ -193,7 +194,7 @@ const map = orange.map(x => ({
     street: column('street').string(),
     postalCode: column('postalCode').string(),
     postalPlace: column('postalPlace').string(),
-    countryCode: column('countryCode').string(),
+    countryCode: column('countryCode').string().enum(['NO', 'SE', 'DK', 'FI', 'IS', 'DE', 'FR', 'NL', 'ES', 'IT']),
   }))
 
 })).map(x => ({
@@ -218,7 +219,8 @@ Then, we define a SQL string. This string outlines the structure of our SQLite d
 Because of a peculiarity in SQLite, which only allows one statement execution at a time, we split this SQL string into separate statements. We do this using the split() method, which breaks up the string at every semicolon.  
 
 <sub>📄 init.ts</sub>
-```javascript
+
+```ts
 import map from './map';
 const db = map.sqlite('demo.db');
 
@@ -337,7 +339,7 @@ await db.transaction(async (db) => {
 __From the browser__  
 You can securely use Orange from the browser by utilizing the Express plugin, which serves to safeguard sensitive database credentials from exposure at the client level. This technique bypasses the need to transmit raw SQL queries directly from the client to the server. Instead, it logs method calls initiated by the client, which are later replayed and authenticated on the server. This not only reinforces security by preventing the disclosure of raw SQL queries on the client side but also facilitates a smoother operation. Essentially, this method mirrors a traditional REST API, augmented with advanced TypeScript tooling for enhanced functionality. You can read more about it in the section called [In the browser](#user-content-in-the-browser)  
 <sub>📄 server.ts</sub>
-```javascript
+```ts
 import map from './map';
 import { json } from 'body-parser';
 import express from 'express';
@@ -354,7 +356,7 @@ express().disable('x-powered-by')
 ```
 
 <sub>📄 browser.ts</sub>
-```javascript
+```ts
 import map from './map';
 
 const db = map.http('http://localhost:3000/orange');
@@ -432,7 +434,7 @@ database_id = "<your-guid-for-the-database>"
 ```
 
 <sub>📄 src/index.ts</sub>  
-```javascript
+```ts
 import map from './map';
 
 export interface Env {
@@ -1173,7 +1175,8 @@ async function deleteRows() {
 Raw sql queries, raw sql filters and transactions are disabled at the http client due to security reasons.  If you would like Orange to support other web frameworks, like nestJs, fastify, etc, please let me know.</p>
 
 <sub>📄 server.ts</sub>
-```javascript
+
+```ts
 import map from './map';
 import { json } from 'body-parser';
 import express from 'express';
@@ -1190,7 +1193,7 @@ express().disable('x-powered-by')
 ```
 
 <sub>📄 browser.ts</sub>
-```javascript
+```ts
 import map from './map';
 
 const db = map.http('http://localhost:3000/orange');
@@ -1221,7 +1224,7 @@ One notable side effect compared to the previous example, is that only the order
 
 <sub>📄 server.ts</sub>
 
-```javascript
+```ts
 import map from './map';
 import { json } from 'body-parser';
 import express from 'express';
@@ -1256,7 +1259,7 @@ function validateToken(req, res, next) {
 
 <sub>📄 browser.ts</sub>
 
-```javascript
+```ts
 import map from './map';
 
 const db = map.http('http://localhost:3000/orange');
@@ -1300,7 +1303,7 @@ async function updateRows() {
 
 ```
 
-__Row Level Security (Postgres)__  
+__Row Level Security__  
 You can enforce tenant isolation at the database level by combining Postgres RLS with Express hooks. The example below mirrors the “Interceptors and base filter” style by putting the tenant id in a (fake) token on the client, then extracting it on the server and setting it inside the transaction. This is convenient for a demo because we can seed data and prove rows are filtered. In a real application you must validate signatures and derive tenant id from a trusted identity source, not from arbitrary client input.  
 
 <sub>📄 setup.sql</sub>
@@ -1328,7 +1331,7 @@ insert into tenant_data (tenant_id, value) values
 
 <sub>📄 server.ts</sub>
 
-```javascript
+```ts
 import map from './map';
 import { json } from 'body-parser';
 import express from 'express';
@@ -1343,6 +1346,7 @@ express().disable('x-powered-by')
   .use('/orange', db.express({
     hooks: {
       transaction: {
+        //beforeBegin: async (db, req) => ...,
         afterBegin: async (db, req) => {
           const tenantId = Number.parseInt(String(req.user?.tenantId ?? ''), 10);
           if (!Number.isFinite(tenantId)) throw new Error('Missing tenant id');
@@ -1351,7 +1355,12 @@ express().disable('x-powered-by')
             sql: 'select set_config(\'app.tenant_id\', ?, true)',
             parameters: [String(tenantId)]
           });
-        }
+        },
+        //beforeCommit: async (db, req) => ...,
+        //afterCommit: async (db, req) => ...,
+        // afterRollback: async (db, req, error) => {
+        //   console.dir(error);
+        // }
       }
     }
   }))
@@ -1380,7 +1389,7 @@ function decodeFakeJwt(token) {
 
 <sub>📄 browser.ts</sub>
 
-```javascript
+```ts
 import map from './map';
 
 const db = map.http('http://localhost:3000/orange');
@@ -1793,7 +1802,8 @@ async function execute() {
 - **`json`** and **`jsonOf<T>`** are represented as an object or array in javascript and maps to JSON, JSONB, NVARCHAR(max) or TEXT (sqlite) in sql.
 
 <sub>📄 map.ts</sub>
-```javascript
+
+```ts
 import orange from 'orange-orm';
 
 interface Pet {
@@ -1816,7 +1826,8 @@ const map = orange.map(x => ({
 }));
 ```
 <sub>📄 map.js</sub>
-```javascript
+
+```js
 import orange from 'orange-orm';
 
 /**
@@ -1843,6 +1854,138 @@ const map = orange.map(x => ({
 ```
 </details>
 
+<details id="enums"><summary><strong>Enums</strong></summary>
+<p>Enums can be defined using object literals, arrays, or TypeScript enums. The <strong><i>enum(...)</i></strong> method uses literal types when possible, so prefer patterns that keep literals (inline objects, <code>as const</code>, or <code>Object.freeze</code> in JS).</p>
+
+<sub>📄 map.ts (TypeScript enum)</sub>
+
+```ts
+enum CountryCode {
+  NORWAY = 'NO',
+  SWEDEN = 'SE',
+  DENMARK = 'DK',
+  FINLAND = 'FI',
+  ICELAND = 'IS',
+  GERMANY = 'DE',
+  FRANCE = 'FR',
+  NETHERLANDS = 'NL',
+  SPAIN = 'ES',
+  ITALY = 'IT',
+}
+
+const map = orange.map(x => ({
+  deliveryAddress: x.table('deliveryAddress').map(({ column }) => ({
+    id: column('id').numeric().primary(),
+    name: column('name').string(),
+    street: column('street').string(),
+    postalCode: column('postalCode').string(),
+    postalPlace: column('postalPlace').string(),
+    countryCode: column('countryCode').string().enum(CountryCode),
+  }))
+}));
+```
+
+
+<sub>📄 map.ts (as const)</sub>
+
+```ts
+const Countries = {
+  NORWAY: 'NO',
+  SWEDEN: 'SE',
+  DENMARK: 'DK',
+  FINLAND: 'FI',
+  ICELAND: 'IS',
+  GERMANY: 'DE',
+  FRANCE: 'FR',
+  NETHERLANDS: 'NL',
+  SPAIN: 'ES',
+  ITALY: 'IT',
+} as const;
+
+const map = orange.map(x => ({
+  deliveryAddress: x.table('deliveryAddress').map(({ column }) => ({
+    id: column('id').numeric().primary(),
+    name: column('name').string(),
+    street: column('street').string(),
+    postalCode: column('postalCode').string(),
+    postalPlace: column('postalPlace').string(),
+    countryCode: column('countryCode').string().enum(Countries),
+  }))
+}));
+```
+
+<sub>📄 map.ts (array)</sub>
+
+```ts
+const map = orange.map(x => ({
+  deliveryAddress: x.table('deliveryAddress').map(({ column }) => ({
+    id: column('id').numeric().primary(),
+    name: column('name').string(),
+    street: column('street').string(),
+    postalCode: column('postalCode').string(),
+    postalPlace: column('postalPlace').string(),
+    countryCode: column('countryCode').string().enum(
+      ['NO', 'SE', 'DK', 'FI', 'IS', 'DE', 'FR', 'NL', 'ES', 'IT']
+    ),
+  }))
+}));
+```
+
+<sub>📄 map.ts (literal object)</sub>
+
+```ts
+const map = orange.map(x => ({
+  deliveryAddress: x.table('deliveryAddress').map(({ column }) => ({
+    id: column('id').numeric().primary(),
+    name: column('name').string(),
+    street: column('street').string(),
+    postalCode: column('postalCode').string(),
+    postalPlace: column('postalPlace').string(),
+    countryCode: column('countryCode').string().enum({
+      NORWAY: 'NO',
+      SWEDEN: 'SE',
+      DENMARK: 'DK',
+      FINLAND: 'FI',
+      ICELAND: 'IS',
+      GERMANY: 'DE',
+      FRANCE: 'FR',
+      NETHERLANDS: 'NL',
+      SPAIN: 'ES',
+      ITALY: 'IT',
+    }),
+  }))
+}));
+```
+
+<sub>📄 map.js (Object.freeze)</sub>
+
+```js
+const Countries = Object.freeze({
+  NORWAY: 'NO',
+  SWEDEN: 'SE',
+  DENMARK: 'DK',
+  FINLAND: 'FI',
+  ICELAND: 'IS',
+  GERMANY: 'DE',
+  FRANCE: 'FR',
+  NETHERLANDS: 'NL',
+  SPAIN: 'ES',
+  ITALY: 'IT',
+});
+
+const map = orange.map(x => ({
+  deliveryAddress: x.table('deliveryAddress').map(({ column }) => ({
+    id: column('id').numeric().primary(),
+    name: column('name').string(),
+    street: column('street').string(),
+    postalCode: column('postalCode').string(),
+    postalPlace: column('postalPlace').string(),
+    countryCode: column('countryCode').string().enum(Countries),
+  }))
+}));
+```
+</details>
+
 <details id="default-values"><summary><strong>Default values</strong></summary>
 <p>Utilizing default values can be especially useful for automatically populating these fields when the underlying database doesn't offer native support for default value generation.  
 
@@ -1869,7 +2012,7 @@ export default map;
 <p>In the previous sections you have already seen the <strong><i>notNull()</i></strong> validator being used on some columns. This will not only generate correct typescript mapping, but also throw an error if value is set to null or undefined. However, sometimes we do not want the notNull-validator to be run on inserts. Typically, when we have an autoincremental key or server generated uuid, it does not make sense to check for null on insert. This is where <strong><i>notNullExceptInsert()</strong></i> comes to rescue. You can also create your own custom validator as shown below. The last kind of validator, is the <a href="https://ajv.js.org/json-schema.html">ajv JSON schema validator</a>. This can be used on json columns as well as any other column type.</p>
 
 <sub>📄 map.ts</sub>
-```javascript
+```ts
 import orange from 'orange-orm';
 
 interface Pet {
@@ -1900,7 +2043,7 @@ const map = orange.map(x => ({
 export default map;
 ```
 <sub>📄 map.js</sub>
-```javascript
+```js
 import orange from 'orange-orm';
 
 /**
@@ -2110,7 +2253,7 @@ async function getCount() {
 
 <sub>📄 map.ts</sub>
 
-```javascript
+```ts
 import orange from 'orange-orm';
 
 const map = orange.map(x => ({
@@ -2126,7 +2269,7 @@ export default map;
 ```
 <sub>📄 sensitive.ts</sub>
 
-```javascript
+```ts
 import map from './map';
 const db = map.sqlite('demo.db');
 

package/dist/index.browser.mjs

@@ -790,8 +790,10 @@ function requireStringify () {
 	}
 
 	function replacer(key, value) {
-		// // @ts-ignore
-		if (value instanceof Date  && !isNaN(value))
+		// @ts-ignore
+		if (typeof value === 'bigint')
+			return value.toString();
+		else if (value instanceof Date  && !isNaN(value))
 			return dateToISOString(value);
 		else
 			return value;
@@ -901,6 +903,8 @@ function requireCreatePatch () {
 				}
 				return copy;
 			}
+			else if (typeof object === 'bigint')
+				return object.toString();
 			else if (isValidDate(object))
 				return dateToIsoString(object);
 			else if (object === Object(object)) {
@@ -1134,8 +1138,9 @@ function requireUtils () {
 					}
 					params.push(sql, filter.parameters);
 				}
-				else if (isObjectFilter(filter, optionalTable))
+				else if (isObjectFilter(filter, optionalTable)) {
 					return newObjectFilter(context, filter, optionalTable);
+				}
 				else
 					params = [filter];
 			} else {
@@ -3091,6 +3096,14 @@ function requireClient () {
 
 			async function getMany(_, strategy) {
 				let metaPromise = getMeta();
+				if (looksLikeFetchStrategy(_) && (strategy === undefined || !looksLikeFetchStrategy(strategy))) {
+					let meta = await metaPromise;
+					if (!isPrimaryKeyObject(meta, _)) {
+						let _strategy = _;
+						_ = strategy;
+						strategy = _strategy;
+					}
+				}
 				strategy = extractFetchingStrategy({}, strategy);
 				let args = [_, strategy].concat(Array.prototype.slice.call(arguments).slice(2));
 				let rows = await getManyCore.apply(null, args);
@@ -3118,13 +3131,69 @@ function requireClient () {
 				return adapter.post(body);
 			}
 
+			function isRawFilter(value) {
+				return value && typeof value === 'object'
+					&& (typeof value.sql === 'string' || typeof value.sql === 'function');
+			}
+
+			function looksLikeFetchStrategy(value) {
+				if (!value || typeof value !== 'object' || Array.isArray(value))
+					return false;
+				if (isRawFilter(value))
+					return false;
+				if (Object.keys(value).length === 0)
+					return true;
+				if ('where' in value || 'orderBy' in value || 'limit' in value || 'offset' in value)
+					return true;
+				for (let key in value) {
+					const v = value[key];
+					if (typeof v === 'boolean')
+						return true;
+					if (v && typeof v === 'object' && !Array.isArray(v))
+						return true;
+				}
+				return false;
+			}
+
+			function isPrimaryKeyObject(meta, value) {
+				if (!value || typeof value !== 'object' || Array.isArray(value))
+					return false;
+				if (isRawFilter(value))
+					return false;
+				const keyNames = meta?.keys?.map(key => key.name);
+				if (!keyNames || keyNames.length === 0)
+					return false;
+				const keys = Object.keys(value);
+				if (keys.length === 0)
+					return false;
+				for (let i = 0; i < keys.length; i++) {
+					const key = keys[i];
+					if (!keyNames.includes(key))
+						return false;
+					const val = value[key];
+					if (val && typeof val === 'object' && !(val instanceof Date))
+						return false;
+				}
+				return true;
+			}
+
+			function normalizeGetOneArgs(meta, filter, strategy) {
+				if (looksLikeFetchStrategy(filter) && (strategy === undefined || !looksLikeFetchStrategy(strategy))) {
+					if (!isPrimaryKeyObject(meta, filter))
+						return { filter: strategy, strategy: filter };
+				}
+				return { filter, strategy };
+			}
+
 			async function getOne(filter, strategy) {
 				let metaPromise = getMeta();
-				strategy = extractFetchingStrategy({}, strategy);
+				let meta = await metaPromise;
+				let normalized = normalizeGetOneArgs(meta, filter, strategy);
+				filter = normalized.filter;
+				strategy = extractFetchingStrategy({}, normalized.strategy);
 				let _strategy = { ...strategy, ...{ limit: 1 } };
 				let args = [filter, _strategy].concat(Array.prototype.slice.call(arguments).slice(2));
 				let rows = await getManyCore.apply(null, args);
-				await metaPromise;
 				if (rows.length === 0)
 					return;
 				return proxify(rows[0], strategy, true);
@@ -5817,6 +5886,37 @@ function requireColumn () {
 			return c;
 		};
 
+		c.enum = function(values) {
+			let list = values;
+			if (Array.isArray(values))
+				list = values;
+			else if (values && typeof values === 'object') {
+				const keys = Object.keys(values);
+				const nonNumericKeys = keys.filter((key) => !/^-?\d+$/.test(key));
+				list = (nonNumericKeys.length ? nonNumericKeys : keys).map((key) => values[key]);
+			}
+			else
+				throw new Error('enum values must be an array');
+			const allowed = new Set(list);
+			column.enum = list;
+			function validate(value) {
+				if (value === undefined || value === null)
+					return;
+				if (!allowed.has(value)) {
+					const formatted = list.map((v) => JSON.stringify(v)).join(', ');
+					throw new Error(`Column ${column.alias} must be one of: ${formatted}`);
+				}
+			}
+			return c.validate(validate);
+		};
+
+		c.enum2 = function(...values) {
+			const list = values.length === 1 && Array.isArray(values[0])
+				? values[0]
+				: values;
+			return c.enum(list);
+		};
+
 		c.default = function(value) {
 			column.default = value;
 			return c;
@@ -5832,7 +5932,6 @@ function requireColumn () {
 			var oldAlias = column.alias;
 			table._aliases.delete(oldAlias);
 			table._aliases.add(alias);
-			delete table[oldAlias];
 			table[alias] = column;
 			column.alias = alias;
 			return c;
@@ -9682,7 +9781,7 @@ function requireWhere$1 () {
 
 			try {
 				let arg = typeof fn === 'function' ? fn(table) : fn;
-				let anyFilter = negotiateRawSqlFilter(context, arg);
+				let anyFilter = negotiateRawSqlFilter(context, arg, table, true);
 				delete table._rootAlias;
 				return anyFilter;
 			}
@@ -12339,7 +12438,7 @@ function requireWhere () {
 
 		function where(context, fn) {
 			let arg = typeof fn === 'function' ? fn(table) : fn;
-			return negotiateRawSqlFilter(context, arg);
+			return negotiateRawSqlFilter(context, arg, table, true);
 		}
 		return where;
 	}

package/dist/index.mjs

@@ -791,8 +791,10 @@ function requireStringify () {
 	}
 
 	function replacer(key, value) {
-		// // @ts-ignore
-		if (value instanceof Date  && !isNaN(value))
+		// @ts-ignore
+		if (typeof value === 'bigint')
+			return value.toString();
+		else if (value instanceof Date  && !isNaN(value))
 			return dateToISOString(value);
 		else
 			return value;
@@ -902,6 +904,8 @@ function requireCreatePatch () {
 				}
 				return copy;
 			}
+			else if (typeof object === 'bigint')
+				return object.toString();
 			else if (isValidDate(object))
 				return dateToIsoString(object);
 			else if (object === Object(object)) {
@@ -1135,8 +1139,9 @@ function requireUtils () {
 					}
 					params.push(sql, filter.parameters);
 				}
-				else if (isObjectFilter(filter, optionalTable))
+				else if (isObjectFilter(filter, optionalTable)) {
 					return newObjectFilter(context, filter, optionalTable);
+				}
 				else
 					params = [filter];
 			} else {
@@ -3092,6 +3097,14 @@ function requireClient () {
 
 			async function getMany(_, strategy) {
 				let metaPromise = getMeta();
+				if (looksLikeFetchStrategy(_) && (strategy === undefined || !looksLikeFetchStrategy(strategy))) {
+					let meta = await metaPromise;
+					if (!isPrimaryKeyObject(meta, _)) {
+						let _strategy = _;
+						_ = strategy;
+						strategy = _strategy;
+					}
+				}
 				strategy = extractFetchingStrategy({}, strategy);
 				let args = [_, strategy].concat(Array.prototype.slice.call(arguments).slice(2));
 				let rows = await getManyCore.apply(null, args);
@@ -3119,13 +3132,69 @@ function requireClient () {
 				return adapter.post(body);
 			}
 
+			function isRawFilter(value) {
+				return value && typeof value === 'object'
+					&& (typeof value.sql === 'string' || typeof value.sql === 'function');
+			}
+
+			function looksLikeFetchStrategy(value) {
+				if (!value || typeof value !== 'object' || Array.isArray(value))
+					return false;
+				if (isRawFilter(value))
+					return false;
+				if (Object.keys(value).length === 0)
+					return true;
+				if ('where' in value || 'orderBy' in value || 'limit' in value || 'offset' in value)
+					return true;
+				for (let key in value) {
+					const v = value[key];
+					if (typeof v === 'boolean')
+						return true;
+					if (v && typeof v === 'object' && !Array.isArray(v))
+						return true;
+				}
+				return false;
+			}
+
+			function isPrimaryKeyObject(meta, value) {
+				if (!value || typeof value !== 'object' || Array.isArray(value))
+					return false;
+				if (isRawFilter(value))
+					return false;
+				const keyNames = meta?.keys?.map(key => key.name);
+				if (!keyNames || keyNames.length === 0)
+					return false;
+				const keys = Object.keys(value);
+				if (keys.length === 0)
+					return false;
+				for (let i = 0; i < keys.length; i++) {
+					const key = keys[i];
+					if (!keyNames.includes(key))
+						return false;
+					const val = value[key];
+					if (val && typeof val === 'object' && !(val instanceof Date))
+						return false;
+				}
+				return true;
+			}
+
+			function normalizeGetOneArgs(meta, filter, strategy) {
+				if (looksLikeFetchStrategy(filter) && (strategy === undefined || !looksLikeFetchStrategy(strategy))) {
+					if (!isPrimaryKeyObject(meta, filter))
+						return { filter: strategy, strategy: filter };
+				}
+				return { filter, strategy };
+			}
+
 			async function getOne(filter, strategy) {
 				let metaPromise = getMeta();
-				strategy = extractFetchingStrategy({}, strategy);
+				let meta = await metaPromise;
+				let normalized = normalizeGetOneArgs(meta, filter, strategy);
+				filter = normalized.filter;
+				strategy = extractFetchingStrategy({}, normalized.strategy);
 				let _strategy = { ...strategy, ...{ limit: 1 } };
 				let args = [filter, _strategy].concat(Array.prototype.slice.call(arguments).slice(2));
 				let rows = await getManyCore.apply(null, args);
-				await metaPromise;
 				if (rows.length === 0)
 					return;
 				return proxify(rows[0], strategy, true);
@@ -5818,6 +5887,37 @@ function requireColumn () {
 			return c;
 		};
 
+		c.enum = function(values) {
+			let list = values;
+			if (Array.isArray(values))
+				list = values;
+			else if (values && typeof values === 'object') {
+				const keys = Object.keys(values);
+				const nonNumericKeys = keys.filter((key) => !/^-?\d+$/.test(key));
+				list = (nonNumericKeys.length ? nonNumericKeys : keys).map((key) => values[key]);
+			}
+			else
+				throw new Error('enum values must be an array');
+			const allowed = new Set(list);
+			column.enum = list;
+			function validate(value) {
+				if (value === undefined || value === null)
+					return;
+				if (!allowed.has(value)) {
+					const formatted = list.map((v) => JSON.stringify(v)).join(', ');
+					throw new Error(`Column ${column.alias} must be one of: ${formatted}`);
+				}
+			}
+			return c.validate(validate);
+		};
+
+		c.enum2 = function(...values) {
+			const list = values.length === 1 && Array.isArray(values[0])
+				? values[0]
+				: values;
+			return c.enum(list);
+		};
+
 		c.default = function(value) {
 			column.default = value;
 			return c;
@@ -5833,7 +5933,6 @@ function requireColumn () {
 			var oldAlias = column.alias;
 			table._aliases.delete(oldAlias);
 			table._aliases.add(alias);
-			delete table[oldAlias];
 			table[alias] = column;
 			column.alias = alias;
 			return c;
@@ -9683,7 +9782,7 @@ function requireWhere$1 () {
 
 			try {
 				let arg = typeof fn === 'function' ? fn(table) : fn;
-				let anyFilter = negotiateRawSqlFilter(context, arg);
+				let anyFilter = negotiateRawSqlFilter(context, arg, table, true);
 				delete table._rootAlias;
 				return anyFilter;
 			}
@@ -12340,7 +12439,7 @@ function requireWhere () {
 
 		function where(context, fn) {
 			let arg = typeof fn === 'function' ? fn(table) : fn;
-			return negotiateRawSqlFilter(context, arg);
+			return negotiateRawSqlFilter(context, arg, table, true);
 		}
 		return where;
 	}
@@ -17753,7 +17852,6 @@ function requireNewDatabase$7 () {
 		};
 
 		c.createTransaction = function(options) {
-			console.dir('create transaction');
 			let domain = createDomain();
 			let transaction = newTransaction(domain, pool);
 			let p = domain.run(() => new Promise(transaction).then(begin));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "orange-orm",
-    "version": "4.10.0-beta.0",
+    "version": "5.0.0-beta.0",
     "publishConfig": {
         "access": "public"
     },

package/src/client/createPatch.js

@@ -90,6 +90,8 @@ module.exports = function createPatch(original, dto, options) {
 			}
 			return copy;
 		}
+		else if (typeof object === 'bigint')
+			return object.toString();
 		else if (isValidDate(object))
 			return dateToIsoString(object);
 		else if (object === Object(object)) {

package/src/client/index.js

@@ -242,6 +242,14 @@ function rdbClient(options = {}) {
 
 		async function getMany(_, strategy) {
 			let metaPromise = getMeta();
+			if (looksLikeFetchStrategy(_) && (strategy === undefined || !looksLikeFetchStrategy(strategy))) {
+				let meta = await metaPromise;
+				if (!isPrimaryKeyObject(meta, _)) {
+					let _strategy = _;
+					_ = strategy;
+					strategy = _strategy;
+				}
+			}
 			strategy = extractFetchingStrategy({}, strategy);
 			let args = [_, strategy].concat(Array.prototype.slice.call(arguments).slice(2));
 			let rows = await getManyCore.apply(null, args);
@@ -269,13 +277,69 @@ function rdbClient(options = {}) {
 			return adapter.post(body);
 		}
 
+		function isRawFilter(value) {
+			return value && typeof value === 'object'
+				&& (typeof value.sql === 'string' || typeof value.sql === 'function');
+		}
+
+		function looksLikeFetchStrategy(value) {
+			if (!value || typeof value !== 'object' || Array.isArray(value))
+				return false;
+			if (isRawFilter(value))
+				return false;
+			if (Object.keys(value).length === 0)
+				return true;
+			if ('where' in value || 'orderBy' in value || 'limit' in value || 'offset' in value)
+				return true;
+			for (let key in value) {
+				const v = value[key];
+				if (typeof v === 'boolean')
+					return true;
+				if (v && typeof v === 'object' && !Array.isArray(v))
+					return true;
+			}
+			return false;
+		}
+
+		function isPrimaryKeyObject(meta, value) {
+			if (!value || typeof value !== 'object' || Array.isArray(value))
+				return false;
+			if (isRawFilter(value))
+				return false;
+			const keyNames = meta?.keys?.map(key => key.name);
+			if (!keyNames || keyNames.length === 0)
+				return false;
+			const keys = Object.keys(value);
+			if (keys.length === 0)
+				return false;
+			for (let i = 0; i < keys.length; i++) {
+				const key = keys[i];
+				if (!keyNames.includes(key))
+					return false;
+				const val = value[key];
+				if (val && typeof val === 'object' && !(val instanceof Date))
+					return false;
+			}
+			return true;
+		}
+
+		function normalizeGetOneArgs(meta, filter, strategy) {
+			if (looksLikeFetchStrategy(filter) && (strategy === undefined || !looksLikeFetchStrategy(strategy))) {
+				if (!isPrimaryKeyObject(meta, filter))
+					return { filter: strategy, strategy: filter };
+			}
+			return { filter, strategy };
+		}
+
 		async function getOne(filter, strategy) {
 			let metaPromise = getMeta();
-			strategy = extractFetchingStrategy({}, strategy);
+			let meta = await metaPromise;
+			let normalized = normalizeGetOneArgs(meta, filter, strategy);
+			filter = normalized.filter;
+			strategy = extractFetchingStrategy({}, normalized.strategy);
 			let _strategy = { ...strategy, ...{ limit: 1 } };
 			let args = [filter, _strategy].concat(Array.prototype.slice.call(arguments).slice(2));
 			let rows = await getManyCore.apply(null, args);
-			await metaPromise;
 			if (rows.length === 0)
 				return;
 			return proxify(rows[0], strategy, true);

package/src/client/stringify.js

@@ -5,11 +5,13 @@ function stringify(value) {
 }
 
 function replacer(key, value) {
-	// // @ts-ignore
-	if (value instanceof Date  && !isNaN(value))
+	// @ts-ignore
+	if (typeof value === 'bigint')
+		return value.toString();
+	else if (value instanceof Date  && !isNaN(value))
 		return dateToISOString(value);
 	else
 		return value;
 }
 
-module.exports = stringify;
+module.exports = stringify;

package/src/map.d.ts

@@ -96,7 +96,9 @@ type ReturnArrayOrObj<W, V1, V2> =
 	V1;
 
 
-type ColumnToType<T> = T extends UuidColumnSymbol
+type ColumnToType<T> = T extends EnumOf<infer E>
+	? E
+	: T extends UuidColumnSymbol
 	? string
 	: T extends StringColumnSymbol
 	? string
@@ -625,6 +627,10 @@ type NotNullExceptInsert = {
 	[' notNullExceptInsert']: boolean;
 };
 
+type EnumOf<T> = {
+	[' enum']: T;
+};
+
 type JsonOf<T> = {
 	[' isjsonOf']: boolean;
 	type: T;
@@ -734,6 +740,11 @@ type DateWithTimeZoneValidator<M> = M extends NotNull
 	};
 
 type StringColumnTypeDef<M> = StringValidator<M> & {
+	enum<const V extends readonly string[]>(values: V): StringColumnTypeDef<M & EnumOf<V[number]>> & EnumOf<V[number]>;
+	enum<const V extends Record<string, string>>(values: V): StringColumnTypeDef<M & EnumOf<V[keyof V]>> & EnumOf<V[keyof V]>;
+	enum<TEnum>(values: Record<string, TEnum>): StringColumnTypeDef<M & EnumOf<TEnum>> & EnumOf<TEnum>;
+	enum<E extends string>(values: readonly E[]): StringColumnTypeDef<M & EnumOf<E>> & EnumOf<E>;
+	enum<E, V extends Record<string, E>>(values: V): StringColumnTypeDef<M & EnumOf<V[keyof V]>> & EnumOf<V[keyof V]>;
 	primary(): StringColumnTypeDef<M & IsPrimary> & IsPrimary;
 	notNull(): StringColumnTypeDef<M & NotNull> & NotNull;
 	notNullExceptInsert(): StringColumnTypeDef<M & NotNull & NotNullExceptInsert> & NotNull & NotNullExceptInsert;
@@ -745,6 +756,10 @@ type StringColumnTypeDef<M> = StringValidator<M> & {
 	M;
 
 type NumericColumnTypeDef<M> = NumericValidator<M> & {
+	enum<const V extends Record<string, number>>(values: V): NumericColumnTypeDef<M & EnumOf<V[keyof V]>> & EnumOf<V[keyof V]>;
+	enum<TEnum>(values: Record<string, TEnum>): NumericColumnTypeDef<M & EnumOf<TEnum>> & EnumOf<TEnum>;
+	enum<E extends number>(values: readonly E[]): NumericColumnTypeDef<M & EnumOf<E>> & EnumOf<E>;
+	enum<E, V extends Record<string, E>>(values: V): NumericColumnTypeDef<M & EnumOf<V[keyof V]>> & EnumOf<V[keyof V]>;
 	primary(): NumericColumnTypeDef<M & IsPrimary> & IsPrimary;
 	notNull(): NumericColumnTypeDef<M & NotNull> & NotNull;
 	notNullExceptInsert(): NumericColumnTypeDef<M & NotNull & NotNullExceptInsert> & NotNull & NotNullExceptInsert;
@@ -756,6 +771,10 @@ type NumericColumnTypeDef<M> = NumericValidator<M> & {
 	M;
 
 type BigIntColumnTypeDef<M> = BigIntValidator<M> & {
+	enum<const V extends Record<string, bigint>>(values: V): BigIntColumnTypeDef<M & EnumOf<V[keyof V]>> & EnumOf<V[keyof V]>;
+	enum<TEnum>(values: Record<string, TEnum>): BigIntColumnTypeDef<M & EnumOf<TEnum>> & EnumOf<TEnum>;
+	enum<E extends bigint>(values: readonly E[]): BigIntColumnTypeDef<M & EnumOf<E>> & EnumOf<E>;
+	enum<E, V extends Record<string, E>>(values: V): BigIntColumnTypeDef<M & EnumOf<V[keyof V]>> & EnumOf<V[keyof V]>;
 	primary(): BigIntColumnTypeDef<M & IsPrimary> & IsPrimary;
 	notNull(): BigIntColumnTypeDef<M & NotNull> & NotNull;
 	notNullExceptInsert(): BigIntColumnTypeDef<M & NotNull & NotNullExceptInsert> & NotNull & NotNullExceptInsert;
@@ -767,6 +786,10 @@ type BigIntColumnTypeDef<M> = BigIntValidator<M> & {
 	M;
 
 type UuidColumnTypeDef<M> = UuidValidator<M> & {
+	enum<const V extends Record<string, string>>(values: V): UuidColumnTypeDef<M & EnumOf<V[keyof V]>> & EnumOf<V[keyof V]>;
+	enum<TEnum>(values: Record<string, TEnum>): UuidColumnTypeDef<M & EnumOf<TEnum>> & EnumOf<TEnum>;
+	enum<E extends string>(values: readonly E[]): UuidColumnTypeDef<M & EnumOf<E>> & EnumOf<E>;
+	enum<E, V extends Record<string, E>>(values: V): UuidColumnTypeDef<M & EnumOf<V[keyof V]>> & EnumOf<V[keyof V]>;
 	primary(): UuidColumnTypeDef<M & IsPrimary> & IsPrimary;
 	notNull(): UuidColumnTypeDef<M & NotNull> & NotNull;
 	notNullExceptInsert(): UuidColumnTypeDef<M & NotNull & NotNullExceptInsert> & NotNull & NotNullExceptInsert;
@@ -789,6 +812,10 @@ type JSONColumnTypeDef<M> = JSONValidator<M> & {
 	M;
 
 type BinaryColumnTypeDef<M> = BinaryValidator<M> & {
+	enum<const V extends Record<string, string>>(values: V): BinaryColumnTypeDef<M & EnumOf<V[keyof V]>> & EnumOf<V[keyof V]>;
+	enum<TEnum>(values: Record<string, TEnum>): BinaryColumnTypeDef<M & EnumOf<TEnum>> & EnumOf<TEnum>;
+	enum<E extends string>(values: readonly E[]): BinaryColumnTypeDef<M & EnumOf<E>> & EnumOf<E>;
+	enum<E, V extends Record<string, E>>(values: V): BinaryColumnTypeDef<M & EnumOf<V[keyof V]>> & EnumOf<V[keyof V]>;
 	primary(): BinaryColumnTypeDef<M & IsPrimary> & IsPrimary;
 	notNull(): BinaryColumnTypeDef<M & NotNull> & NotNull;
 	notNullExceptInsert(): BinaryColumnTypeDef<M & NotNull & NotNullExceptInsert> & NotNull & NotNullExceptInsert;
@@ -800,6 +827,10 @@ type BinaryColumnTypeDef<M> = BinaryValidator<M> & {
 	M;
 
 type BooleanColumnTypeDef<M> = BooleanValidator<M> & {
+	enum<const V extends Record<string, boolean>>(values: V): BooleanColumnTypeDef<M & EnumOf<V[keyof V]>> & EnumOf<V[keyof V]>;
+	enum<TEnum>(values: Record<string, TEnum>): BooleanColumnTypeDef<M & EnumOf<TEnum>> & EnumOf<TEnum>;
+	enum<E extends boolean>(values: readonly E[]): BooleanColumnTypeDef<M & EnumOf<E>> & EnumOf<E>;
+	enum<E, V extends Record<string, E>>(values: V): BooleanColumnTypeDef<M & EnumOf<V[keyof V]>> & EnumOf<V[keyof V]>;
 	primary(): BooleanColumnTypeDef<M & IsPrimary> & IsPrimary;
 	notNull(): BooleanColumnTypeDef<M & NotNull> & NotNull;
 	notNullExceptInsert(): BooleanColumnTypeDef<M & NotNull & NotNullExceptInsert> & NotNull & NotNullExceptInsert;
@@ -811,6 +842,10 @@ type BooleanColumnTypeDef<M> = BooleanValidator<M> & {
 	M;
 
 type DateColumnTypeDef<M> = DateValidator<M> & {
+	enum<const V extends Record<string, string | Date>>(values: V): DateColumnTypeDef<M & EnumOf<V[keyof V]>> & EnumOf<V[keyof V]>;
+	enum<TEnum>(values: Record<string, TEnum>): DateColumnTypeDef<M & EnumOf<TEnum>> & EnumOf<TEnum>;
+	enum<E extends string | Date>(values: readonly E[]): DateColumnTypeDef<M & EnumOf<E>> & EnumOf<E>;
+	enum<E, V extends Record<string, E>>(values: V): DateColumnTypeDef<M & EnumOf<V[keyof V]>> & EnumOf<V[keyof V]>;
 	primary(): DateColumnTypeDef<M & IsPrimary> & IsPrimary;
 	notNull(): DateColumnTypeDef<M & NotNull> & NotNull;
 	notNullExceptInsert(): DateColumnTypeDef<M & NotNull & NotNullExceptInsert> & NotNull & NotNullExceptInsert;
@@ -822,6 +857,10 @@ type DateColumnTypeDef<M> = DateValidator<M> & {
 	M;
 
 type DateWithTimeZoneColumnTypeDef<M> = DateValidator<M> & {
+	enum<const V extends Record<string, string | Date>>(values: V): DateWithTimeZoneColumnTypeDef<M & EnumOf<V[keyof V]>> & EnumOf<V[keyof V]>;
+	enum<TEnum>(values: Record<string, TEnum>): DateWithTimeZoneColumnTypeDef<M & EnumOf<TEnum>> & EnumOf<TEnum>;
+	enum<E extends string | Date>(values: readonly E[]): DateWithTimeZoneColumnTypeDef<M & EnumOf<E>> & EnumOf<E>;
+	enum<E, V extends Record<string, E>>(values: V): DateWithTimeZoneColumnTypeDef<M & EnumOf<V[keyof V]>> & EnumOf<V[keyof V]>;
 	primary(): DateWithTimeZoneColumnTypeDef<M & IsPrimary> & IsPrimary;
 	notNull(): DateWithTimeZoneColumnTypeDef<M & NotNull> & NotNull;
 	notNullExceptInsert(): DateWithTimeZoneColumnTypeDef<M & NotNull & NotNullExceptInsert> & NotNull & NotNullExceptInsert;
@@ -1000,7 +1039,9 @@ type ExtractPrimaryKeyNames<T> =
 type RelationTarget<T> =
   T extends { __tableAlias: infer S } ? Extract<S, string> : string;
 
-type ColumnToSchemaType<T> =
+type EnumSchema<T> = T extends EnumOf<infer E> ? { ' enum': readonly E[] } : {};
+
+type ColumnToSchemaType<T> = (
   T extends JsonOf<infer U>
     ? { ' type': 'json'; ' tsType': U }
       & (T extends NotNullExceptInsert ? { ' notNull': true; ' notNullExceptInsert': true }
@@ -1046,7 +1087,8 @@ type ColumnToSchemaType<T> =
       & (T extends NotNullExceptInsert ? { ' notNull': true; ' notNullExceptInsert': true }
          : T extends NotNull ? { ' notNull': true }
          : {}) :
-  never;
+  never
+) & EnumSchema<T>;
 
 export type MappedDbDef<T> = {
   map<V extends AllowedDbMap<V>>(
@@ -1059,4 +1101,4 @@ export type MappedDbDef<T> = {
    * Usage: type Schema = ReturnType<typeof db.toSchema>
    */
   toSchema: <U = T>() => SchemaFromMappedDb<U>;
-} & T & DbConnectable<T>;
+} & T & DbConnectable<T>;

package/src/map2.d.ts

@@ -10,6 +10,7 @@ export type ORMColumnType = 'string' | 'bigint' | 'uuid' | 'date' | 'numeric' |
 // Base column definition with space-prefixed required properties
 export type ORMColumnDefinition = {
   ' type': ORMColumnType;
+  ' enum'?: readonly (string | number | boolean | Date)[] | Record<string, string | number | boolean | Date>;
   ' notNull'?: boolean;
   ' notNullExceptInsert'?: boolean;
 };
@@ -24,7 +25,7 @@ export type ORMJsonColumnDefinition<T = any> = {
 
 type NormalizeColumn<T> =
   T extends ORMColumnType
-  ? { ' type': T; ' notNull'?: boolean; ' notNullExceptInsert'?: boolean }
+  ? { ' type': T; ' enum'?: readonly (string | number | boolean | Date)[] | Record<string, string | number | boolean | Date>; ' notNull'?: boolean; ' notNullExceptInsert'?: boolean }
   : T extends { ' type': ORMColumnType }
   ? { ' notNull'?: boolean; ' notNullExceptInsert'?: boolean } & T
   : T extends { ' type': 'json'; ' tsType': any }
@@ -41,6 +42,8 @@ type IsRequiredInsert<CT> =
   : false; // Otherwise, it's optional
 
 type ColumnTypeToTS<CT> =
+  NormalizeColumn<CT> extends { ' enum': readonly (infer E)[] } ? E :
+  NormalizeColumn<CT> extends { ' enum': Record<string, infer E> } ? E :
   NormalizeColumn<CT>[' type'] extends 'numeric' ? number :
   NormalizeColumn<CT>[' type'] extends 'boolean' ? boolean :
   NormalizeColumn<CT>[' type'] extends 'json'
@@ -674,41 +677,33 @@ type AggregateCustomSelectorProperties<M extends Record<string, TableDefinition<
 
 export type TableClient<M extends Record<string, TableDefinition<M>>, K extends keyof M> = {
   // Array methods - return arrays with array-level active record methods, but individual items are plain
-  getAll(): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, {}>>>, M, K>>;
-  getAll<strategy extends FetchStrategy<M, K>>(strategy: strategy): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, strategy>>>, M, K>>;
-  getMany(filter?: RawFilter | Array<PrimaryKeyObject<M, K>>): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, {}>>>, M, K>>;
-  getMany<strategy extends FetchStrategy<M, K>>(filter?: RawFilter | Array<PrimaryKeyObject<M, K>>, strategy?: strategy): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, strategy>>>, M, K>>;
+  getMany<strategy extends FetchStrategy<M, K>>(strategy?: strategy): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, strategy>>>, M, K>>;
 
   // Aggregate methods - return plain objects (no active record methods)
   aggregate<strategy extends AggregateStrategy<M, K>>(strategy: strategy): Promise<Array<DeepExpand<AggregateCustomSelectorProperties<M, K, strategy>>>>;
 
   // Single item methods - return individual objects with individual active record methods
-  getOne<strategy extends FetchStrategy<M, K>>(
-    filter?: RawFilter | Array<PrimaryKeyObject<M, K>>
-  ): Promise<WithActiveRecord<DeepExpand<Selection<M, K, strategy>>, M, K>>;
-
-  getOne<strategy extends FetchStrategy<M, K>>(
-    filter?: RawFilter | Array<PrimaryKeyObject<M, K>>,
+  getOne<strategy extends FetchStrategy<M, K> = {}>(
     strategy?: strategy
-  ): Promise<WithActiveRecord<DeepExpand<Selection<M, K, strategy>>, M, K>>;
+  ): Promise<WithActiveRecord<DeepExpand<Selection<M, K, strategy>>, M, K> | undefined>;
 
   getById<strategy extends FetchStrategy<M, K>>(
     ...args: [...PrimaryKeyArgs<M, K>, strategy: strategy]
-  ): Promise<WithActiveRecord<DeepExpand<Selection<M, K, strategy>>, M, K>>;
+  ): Promise<WithActiveRecord<DeepExpand<Selection<M, K, strategy>>, M, K> | undefined>;
 
   getById(
     ...args: [...PrimaryKeyArgs<M, K>]
-  ): Promise<WithActiveRecord<DeepExpand<Selection<M, K, {}>>, M, K>>;
+  ): Promise<WithActiveRecord<DeepExpand<Selection<M, K, {}>>, M, K>  | undefined>;
 
   // UPDATED: Bulk update methods with relations support
   update(
     row: UpdateRowWithRelations<M, K>,
-    opts: { where: (row: RootTableRefs<M, K>) => RawFilter }
+    opts: { where: (row: RootTableRefs<M, K>) => RawFilter | Array<PrimaryKeyObject<M, K>> }
   ): Promise<void>;
 
   update<strategy extends FetchStrategy<M, K>>(
     row: UpdateRowWithRelations<M, K>,
-    opts: { where: (row: RootTableRefs<M, K>) => RawFilter },
+    opts: { where: (row: RootTableRefs<M, K>) => RawFilter | Array<PrimaryKeyObject<M, K>> },
     strategy: strategy
   ): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, strategy>>>, M, K>>;
 

package/src/nodeSqlite/newDatabase.js

@@ -48,7 +48,6 @@ function newDatabase(connectionString, poolOptions) {
 	};
 
 	c.createTransaction = function(options) {
-		console.dir('create transaction');
 		let domain = createDomain();
 		let transaction = newTransaction(domain, pool);
 		let p = domain.run(() => new Promise(transaction).then(begin));

package/src/table/column/utils.js

@@ -80,8 +80,9 @@ function negotiateRawSqlFilter(context, filter, optionalTable, emptyArrayMeansFa
 				}
 				params.push(sql, filter.parameters);
 			}
-			else if (isObjectFilter(filter, optionalTable))
+			else if (isObjectFilter(filter, optionalTable)) {
 				return newObjectFilter(context, filter, optionalTable);
+			}
 			else
 				params = [filter];
 		} else {
@@ -110,4 +111,4 @@ function newObjectFilter(context, object, table) {
 }
 
 
-module.exports = { negotiateRawSqlFilter, newBoolean};
+module.exports = { negotiateRawSqlFilter, newBoolean};

package/src/table/column.js

@@ -54,6 +54,37 @@ function defineColumn(column, table) {
 		return c;
 	};
 
+	c.enum = function(values) {
+		let list = values;
+		if (Array.isArray(values))
+			list = values;
+		else if (values && typeof values === 'object') {
+			const keys = Object.keys(values);
+			const nonNumericKeys = keys.filter((key) => !/^-?\d+$/.test(key));
+			list = (nonNumericKeys.length ? nonNumericKeys : keys).map((key) => values[key]);
+		}
+		else
+			throw new Error('enum values must be an array');
+		const allowed = new Set(list);
+		column.enum = list;
+		function validate(value) {
+			if (value === undefined || value === null)
+				return;
+			if (!allowed.has(value)) {
+				const formatted = list.map((v) => JSON.stringify(v)).join(', ');
+				throw new Error(`Column ${column.alias} must be one of: ${formatted}`);
+			}
+		}
+		return c.validate(validate);
+	};
+
+	c.enum2 = function(...values) {
+		const list = values.length === 1 && Array.isArray(values[0])
+			? values[0]
+			: values;
+		return c.enum(list);
+	};
+
 	c.default = function(value) {
 		column.default = value;
 		return c;
@@ -69,7 +100,6 @@ function defineColumn(column, table) {
 		var oldAlias = column.alias;
 		table._aliases.delete(oldAlias);
 		table._aliases.add(alias);
-		delete table[oldAlias];
 		table[alias] = column;
 		column.alias = alias;
 		return c;
@@ -160,4 +190,4 @@ function inspect(obj) {
 }
 
 
-module.exports = defineColumn;
+module.exports = defineColumn;

package/src/table/relatedTable/where.js

@@ -11,7 +11,7 @@ function newWhere(_relations, _depth) {
 
 		try {
 			let arg = typeof fn === 'function' ? fn(table) : fn;
-			let anyFilter = negotiateRawSqlFilter(context, arg);
+			let anyFilter = negotiateRawSqlFilter(context, arg, table, true);
 			delete table._rootAlias;
 			return anyFilter;
 		}
@@ -40,4 +40,4 @@ function newWhere(_relations, _depth) {
 
 }
 
-module.exports = newWhere;
+module.exports = newWhere;

package/src/table/where.js

@@ -4,9 +4,9 @@ function newWhere(table) {
 
 	function where(context, fn) {
 		let arg = typeof fn === 'function' ? fn(table) : fn;
-		return negotiateRawSqlFilter(context, arg);
+		return negotiateRawSqlFilter(context, arg, table, true);
 	}
 	return where;
 }
 
-module.exports = newWhere;
+module.exports = newWhere;