orange-orm 5.0.0-beta.3 → 5.0.0-beta.4

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,14 +127,14 @@ async function updateRow() {
 ```
 <sub>📄 filter.ts</sub>
 
-```javascript
+```ts
 import map from './map';
 const db = map.sqlite('demo.db');
 
 getRows();
 
 async function getRows() {
-  const orders = await db.order.getAll({
+  const orders = await db.order.getMany({
     where: x => x.lines.any(line => line.product.contains('broomstick'))
       .and(x.customer.name.startsWith('Harry')),
     lines: {
@@ -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');
 
@@ -310,34 +312,13 @@ __Why close ?__
 In serverless environments (e.g. AWS Lambda, Vercel, Cloudflare Workers) execution contexts are frequently frozen and resumed. Explicitly closing the client or pool ensures that file handles are released promptly and prevents “database locked” errors between invocations.  
 
 __SQLite user-defined functions__  
-You can register custom SQLite functions on the connection using `db.function(name, fn)`.  
-
-```javascript
-import map from './map';
-const db = map.sqlite('demo.db');
-
-db.function('add_prefix', (text, prefix) => `${prefix}${text}`);
-
-const rows = await db.query(
-  "select id, name, add_prefix(name, '[VIP] ') as prefixedName from customer"
-);
-```
-
-If you need the function inside a transaction, register it within the transaction callback to ensure it is available on that connection.  
-
-```javascript
-await db.transaction(async (db) => {
-  db.function('add_prefix', (text, prefix) => `${prefix}${text}`);
-  return db.query(
-    "select id, name, add_prefix(name, '[VIP] ') as prefixedName from customer"
-  );
-});
-```
+You can register custom SQLite functions using `db.function(name, fn)`.  
+For full behavior, runtime caveats, and examples, see [SQLite user-defined functions](#sqlite-user-defined-functions).
 
 __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 +335,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 +413,7 @@ database_id = "<your-guid-for-the-database>"
 ```
 
 <sub>📄 src/index.ts</sub>  
-```javascript
+```ts
 import map from './map';
 
 export interface Env {
@@ -443,7 +424,7 @@ export interface Env {
 export default {
   async fetch(request, env): Promise<Response> {
     const db = map.d1(env.DB);
-    const customers = await db.customer.getAll();
+    const customers = await db.customer.getMany();
     return Response.json(customers);
   },
 } satisfies ExportedHandler<Env>;
@@ -611,7 +592,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const orders = await db.order.getAll({
+  const orders = await db.order.getMany({
     customer: true, 
     deliveryAddress: true, 
     lines: {
@@ -630,7 +611,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const orders = await db.order.getAll({
+  const orders = await db.order.getMany({
     offset: 1,
     orderBy: ['orderDate desc', 'id'],
     limit: 10,
@@ -662,7 +643,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const orders = await db.order.getAll({
+  const orders = await db.order.getMany({
     numberOfLines: x => x.count(x => x.lines.id),
     totalAmount: x => x.sum(x => lines.amount),
     balance: x => x.customer.balance
@@ -679,7 +660,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const orders = await db.order.getAll({
+  const orders = await db.order.getMany({
     where: x => x.lines.any(line => line.product.contains('i'))
       .and(x.customer.balance.greaterThan(180)),
     customer: true, 
@@ -688,14 +669,13 @@ async function getRows() {
   });
 }
 ```
-You can also use the alternative syntax for the `where-filter`. This way, the filter can be constructed independently from the fetching strategy. Keep in mind that you must use the `getMany` method instead of the `getAll` method.  
-It is also possible to combine `where-filter` with the independent filter when using the `getMany` method.  
+You can also use the alternative syntax for the `where` filter. This way, the filter can be constructed independently from the fetching strategy and passed in via the `where` clause.  
 ```javascript
 async function getRows() {
   const filter = db.order.lines.any(line => line.product.contains('i'))
                  .and(db.order.customer.balance.greaterThan(180));
-  const orders = await db.order.getMany(filter, {
-    //where: x => ... can be combined as well
+  const orders = await db.order.getMany({
+    where: filter,
     customer: true, 
     deliveryAddress: true, 
     lines: true
@@ -810,7 +790,7 @@ const db = map.sqlite('demo.db');
 update();
 
 async function update() {
-  let orders = await db.order.getAll({
+  let orders = await db.order.getMany({
     orderBy: 'id',
     lines: true, 
     deliveryAddress: true, 
@@ -1043,7 +1023,7 @@ const db = map.sqlite('demo.db');
 updateInsertDelete();
 
 async function updateInsertDelete() {    
-  const orders = await db.order.getAll({
+  const orders = await db.order.getMany({
     customer: true, 
     deliveryAddress: true, 
     lines: true
@@ -1090,7 +1070,7 @@ const db = map.sqlite('demo.db');
 deleteRows();
 
 async function deleteRows() {  
-  let orders = await db.order.getAll({
+  let orders = await db.order.getMany({
     where: x => x.customer.name.eq('George')
   });
 
@@ -1106,7 +1086,7 @@ const db = map.sqlite('demo.db');
 deleteRows();
 
 async function deleteRows() {
-  let orders = await db.order.getAll({
+  let orders = await db.order.getMany({
     where: x => x.deliveryAddress.name.eq('George'),
     customer: true, 
     deliveryAddress: true, 
@@ -1174,7 +1154,7 @@ Raw sql queries, raw sql filters and transactions are disabled at the http clien
 
 <sub>📄 server.ts</sub>
 
-```javascript
+```ts
 import map from './map';
 import { json } from 'body-parser';
 import express from 'express';
@@ -1191,7 +1171,7 @@ express().disable('x-powered-by')
 ```
 
 <sub>📄 browser.ts</sub>
-```javascript
+```ts
 import map from './map';
 
 const db = map.http('http://localhost:3000/orange');
@@ -1222,7 +1202,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';
@@ -1257,7 +1237,7 @@ function validateToken(req, res, next) {
 
 <sub>📄 browser.ts</sub>
 
-```javascript
+```ts
 import map from './map';
 
 const db = map.http('http://localhost:3000/orange');
@@ -1301,9 +1281,8 @@ 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.  
-Available transaction hooks are `beforeBegin`, `afterBegin`, `beforeCommit`, `afterCommit`, and `afterRollback`.
 
 <sub>📄 setup.sql</sub>
 
@@ -1330,7 +1309,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';
@@ -1345,6 +1324,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');
@@ -1353,7 +1333,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);
+        // }
       }
     }
   }))
@@ -1382,7 +1367,7 @@ function decodeFakeJwt(token) {
 
 <sub>📄 browser.ts</sub>
 
-```javascript
+```ts
 import map from './map';
 
 const db = map.http('http://localhost:3000/orange');
@@ -1412,7 +1397,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const rows = await db.order.getAll({
+  const rows = await db.order.getMany({
     deliveryAddress: true 
   });  
 }
@@ -1428,7 +1413,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const rows = await db.order.getAll({
+  const rows = await db.order.getMany({
     orderDate: false,
     deliveryAddress: {
       countryCode: true,
@@ -1452,7 +1437,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const rows = await db.customer.getAll({
+  const rows = await db.customer.getMany({
     where x => x.name.equal('Harry')
   });
 }
@@ -1465,7 +1450,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const rows = await db.customer.getAll({
+  const rows = await db.customer.getMany({
     where x => x.name.notEqual('Harry')
   });
 }
@@ -1478,7 +1463,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const rows = await db.customer.getAll({
+  const rows = await db.customer.getMany({
     where: x => x.name.contains('arr')
   });
 }
@@ -1493,7 +1478,7 @@ getRows();
 async function getRows() {
   const filter = db.customer.name.startsWith('Harr');
 
-  const rows = await db.customer.getAll({
+  const rows = await db.customer.getMany({
     where: x => x.name.startsWith('Harr')
   });
 }
@@ -1506,7 +1491,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const rows = await db.customer.getAll({
+  const rows = await db.customer.getMany({
     where: x => x.name.endsWith('arry')
   });
 }
@@ -1519,7 +1504,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const rows = await db.order.getAll({
+  const rows = await db.order.getMany({
     where: x => x.orderDate.greaterThan('2023-07-14T12:00:00')
   });
 }
@@ -1532,7 +1517,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const rows = await db.order.getAll({
+  const rows = await db.order.getMany({
     where: x => x.orderDate.greaterThanOrEqual('2023-07-14T12:00:00')
   });
 }
@@ -1545,7 +1530,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const rows = await db.order.getAll({
+  const rows = await db.order.getMany({
     where: x => x.orderDate.lessThan('2023-07-14T12:00:00')
   });
 }
@@ -1558,7 +1543,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const rows = await db.order.getAll({
+  const rows = await db.order.getMany({
     where: x => x.orderDate.lessThanOrEqual('2023-07-14T12:00:00')
   });
 }
@@ -1571,7 +1556,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const rows = await db.order.getAll({
+  const rows = await db.order.getMany({
     where: x => x.orderDate.between('2023-07-14T12:00:00', '2024-07-14T12:00:00')
   });
 }
@@ -1584,7 +1569,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const rows = await db.order.getAll({
+  const rows = await db.order.getMany({
     where: x => x.customer.name.in('George', 'Harry')
   });
 
@@ -1606,11 +1591,11 @@ async function getRows() {
     parameters: ['%arry']
   };                 
   
-  const rowsWithRaw = await db.customer.getAll({
+  const rowsWithRaw = await db.customer.getMany({
     where: () => rawFilter
   });
 
-  const rowsWithCombined = await db.customer.getAll({
+  const rowsWithCombined = await db.customer.getMany({
     where: x => x.balance.greaterThan(100).and(rawFilter)
   });  
 }
@@ -1628,7 +1613,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const orders = await db.order.getAll({
+  const orders = await db.order.getMany({
     lines: {
       where: x => x.product.contains('broomstick')
     },
@@ -1650,7 +1635,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const rows = await db.order.getAll({
+  const rows = await db.order.getMany({
     where: x => x.customer.name.equal('Harry')
       .and(x.orderDate.greaterThan('2023-07-14T12:00:00'))
   });  
@@ -1665,7 +1650,7 @@ getRows();
 
 async function getRows() {
 
-  const rows = await db.order.getAll({
+  const rows = await db.order.getMany({
     where: y => y.customer( x => x.name.equal('George')
       .or(x.name.equal('Harry')))
   });  
@@ -1680,7 +1665,7 @@ getRows();
 
 async function getRows() {
   //Neither George nor Harry
-  const rows = await db.order.getAll({
+  const rows = await db.order.getMany({
     where: y => y.customer(x => x.name.equal('George')
         .or(x.name.equal('Harry')))
       .not()
@@ -1695,7 +1680,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const rows = await db.order.getAll({
+  const rows = await db.order.getMany({
     where: x => x.deliveryAddress.exists()
   });  
 }
@@ -1716,7 +1701,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const rows = await db.order.getAll({
+  const rows = await db.order.getMany({
     where: y => y.lines.any(x => x.product.contains('guitar'))
     //equivalent syntax:
     //where: x => x.lines.product.contains('guitar')
@@ -1732,7 +1717,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const rows = await db.order.getAll({
+  const rows = await db.order.getMany({
     where: y => y.lines.all(x => x.product.contains('a'))
   });  
 }
@@ -1746,7 +1731,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const rows = await db.order.getAll({
+  const rows = await db.order.getMany({
     where: y => y.lines.none(x => x.product.equal('Magic wand'))
   });  
 }
@@ -1795,7 +1780,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 {
@@ -1818,7 +1804,8 @@ const map = orange.map(x => ({
 }));
 ```
 <sub>📄 map.js</sub>
-```javascript
+
+```js
 import orange from 'orange-orm';
 
 /**
@@ -1845,6 +1832,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.  
 
@@ -1871,7 +1990,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 {
@@ -1902,7 +2021,7 @@ const map = orange.map(x => ({
 export default map;
 ```
 <sub>📄 map.js</sub>
-```javascript
+```js
 import orange from 'orange-orm';
 
 /**
@@ -2040,6 +2159,43 @@ async function getRows() {
 ```
 </details>
 
+<details id="sqlite-user-defined-functions"><summary><strong>SQLite user-defined functions</strong></summary>
+
+You can register custom SQLite functions on the connection using `db.function(name, fn)`.
+
+The `fn` argument is your user-defined callback:
+- It is invoked by SQLite every time the SQL function is called.
+- Callback arguments are positional and match the SQL call (for example, `my_fn(a, b)` maps to `(a, b)`).
+- Return a SQLite-compatible scalar value (for example text, number, or `null`).
+- Throwing inside the callback fails the SQL statement.
+
+`db.function(...)` is sync-only in Node and Deno, but can be async or sync in Bun.
+
+```javascript
+import map from './map';
+const db = map.sqlite('demo.db');
+
+await db.function('add_prefix', (text, prefix) => `${prefix}${text}`);
+
+const rows = await db.query(
+  "select id, name, add_prefix(name, '[VIP] ') as prefixedName from customer"
+);
+```
+
+If you need the function inside a transaction, register it within the transaction callback to ensure it is available on that connection.
+
+```javascript
+await db.transaction(async (db) => {
+  await db.function('add_prefix', (text, prefix) => `${prefix}${text}`);
+  return db.query(
+    "select id, name, add_prefix(name, '[VIP] ') as prefixedName from customer"
+  );
+});
+```
+
+`db.function(...)` is available on direct SQLite connections (for example `map.sqlite(...)`) and not through `map.http(...)`.
+</details>
+
 <details id="aggregates"><summary><strong>Aggregate functions</strong></summary>
 
 You can count records and aggregate numerical columns.  This can either be done across rows or separately for each row.  
@@ -2061,7 +2217,7 @@ const db = map.sqlite('demo.db');
 getRows();
 
 async function getRows() {
-  const orders = await db.order.getAll({
+  const orders = await db.order.getMany({
     numberOfLines: x => x.count(x => x.lines.id),
     totalAmount: x => x.sum(x => lines.amount),
     balance: x => x.customer.balance
@@ -2112,7 +2268,7 @@ async function getCount() {
 
 <sub>📄 map.ts</sub>
 
-```javascript
+```ts
 import orange from 'orange-orm';
 
 const map = orange.map(x => ({
@@ -2128,7 +2284,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

@@ -1197,7 +1197,7 @@ function requireEmptyFilter () {
 		return emptyFilter.and.apply(null, arguments);
 	}
 
-	emptyFilter.sql = parameterized.sql;
+	emptyFilter.sql = parameterized.sql.bind(parameterized);
 	emptyFilter.parameters = parameterized.parameters;
 
 	emptyFilter.and = function(context, other) {
@@ -5888,6 +5888,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;
@@ -5903,7 +5934,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;
@@ -12745,7 +12775,10 @@ function requireTable () {
 			row[property] = value;
 		};
 
-		table.delete = _delete.bind(null, table);
+		table.delete = function(context, ...rest) {
+			const args = [context, table, ...rest];
+			return _delete.apply(null, args);
+		};
 		table.cascadeDelete = function(context, ...rest) {
 			const args = [context, table, ...rest];
 			return cascadeDelete.apply(null, args);

package/dist/index.mjs

@@ -1198,7 +1198,7 @@ function requireEmptyFilter () {
 		return emptyFilter.and.apply(null, arguments);
 	}
 
-	emptyFilter.sql = parameterized.sql;
+	emptyFilter.sql = parameterized.sql.bind(parameterized);
 	emptyFilter.parameters = parameterized.parameters;
 
 	emptyFilter.and = function(context, other) {
@@ -5889,6 +5889,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;
@@ -5904,7 +5935,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;
@@ -12746,7 +12776,10 @@ function requireTable () {
 			row[property] = value;
 		};
 
-		table.delete = _delete.bind(null, table);
+		table.delete = function(context, ...rest) {
+			const args = [context, table, ...rest];
+			return _delete.apply(null, args);
+		};
 		table.cascadeDelete = function(context, ...rest) {
 			const args = [context, table, ...rest];
 			return cascadeDelete.apply(null, args);

package/docs/changelog.md

@@ -1,4 +1,9 @@
 ## Changelog
+__5.0.0__  
+Breaking: `getAll` was removed. Use `getMany` instead (now with the same signature as the removed `getAll`).  
+ExpressJS: Before/after hooks to facilitate row-level security [#135](https://github.com/alfateam/orange-orm/issues/135)  
+SQLite: Support for invoking user-defined functions [#145](https://github.com/alfateam/orange-orm/issues/145)  
+Support for enums [#100](https://github.com/alfateam/orange-orm/issues/100)  
 __4.9.1__  
 Fix: Avoid double-quoting aliases in discriminator join SQL [#144](https://github.com/alfateam/orange-orm/issues/144)    
 __4.9.0__  

package/package.json

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

package/src/emptyFilter.js

@@ -4,7 +4,7 @@ function emptyFilter() {
 	return emptyFilter.and.apply(null, arguments);
 }
 
-emptyFilter.sql = parameterized.sql;
+emptyFilter.sql = parameterized.sql.bind(parameterized);
 emptyFilter.parameters = parameterized.parameters;
 
 emptyFilter.and = function(context, other) {

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'
@@ -163,7 +166,7 @@ type BaseFetchStrategy<M extends Record<string, TableDefinition<M>>, K extends k
   orderBy?: OrderBy<M, K>;
   limit?: number;
   offset?: number;
-  where?: WhereFunc<M, K>;
+  where?: WhereClause<M, K>;
 };
 
 export type PrimaryKeyObject<M extends Record<string, TableDefinition<M>>, K extends keyof M> =
@@ -341,18 +344,25 @@ export type AggregateStrategy<M extends Record<string, TableDefinition<M>>, K ex
   BaseAggregateStrategy<M, K>
   | CustomAggregateSelectors<M, K>;
 
-type WhereFunc<M extends Record<string, TableDefinition<M>>, K extends keyof M> = (row: RootTableRefs<M, K>) => RawFilter | Array<PrimaryKeyObject<M, K>>;
+type WhereFilter<M extends Record<string, TableDefinition<M>>, K extends keyof M> =
+  RawFilter | Array<PrimaryKeyObject<M, K>>;
+
+type WhereFunc<M extends Record<string, TableDefinition<M>>, K extends keyof M> =
+  (row: RootTableRefs<M, K>) => WhereFilter<M, K>;
+
+type WhereClause<M extends Record<string, TableDefinition<M>>, K extends keyof M> =
+  WhereFilter<M, K> | WhereFunc<M, K> | (() => WhereFilter<M, K>);
 
 type BaseAggregateStrategy<M extends Record<string, TableDefinition<M>>, K extends keyof M> = {
   limit?: number;
   offset?: number;
-  where?: WhereFunc<M, K>;
+  where?: WhereClause<M, K>;
 };
 
 type CustomAggregateSelectors<M extends Record<string, TableDefinition<M>>, K extends keyof M> = {
   [key: string]: (row: RootSelectionRefs<M, K>) => ValidSelectorReturnTypes<M, K>;
 } & {
-  where?: WhereFunc<M, K>;
+  where?: WhereClause<M, K>;
 } & {
   // Explicitly prevent limit/offset in selectors
   limit?: never;
@@ -674,13 +684,13 @@ 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
-  getMany<strategy extends FetchStrategy<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> = {}>(
+  getOne<strategy extends FetchStrategy<M, K>>(
     strategy?: strategy
   ): Promise<WithActiveRecord<DeepExpand<Selection<M, K, strategy>>, M, K> | undefined>;
 
@@ -695,12 +705,12 @@ export type TableClient<M extends Record<string, TableDefinition<M>>, K extends
   // UPDATED: Bulk update methods with relations support
   update(
     row: UpdateRowWithRelations<M, K>,
-    opts: { where: (row: RootTableRefs<M, K>) => RawFilter | Array<PrimaryKeyObject<M, K>> }
+    opts: { where: WhereClause<M, K> }
   ): Promise<void>;
 
   update<strategy extends FetchStrategy<M, K>>(
     row: UpdateRowWithRelations<M, K>,
-    opts: { where: (row: RootTableRefs<M, K>) => RawFilter | Array<PrimaryKeyObject<M, K>> },
+    opts: { where: WhereClause<M, K> },
     strategy: strategy
   ): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, strategy>>>, M, K>>;
 

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.js

@@ -192,7 +192,10 @@ function _new(tableName) {
 		row[property] = value;
 	};
 
-	table.delete = _delete.bind(null, table);
+	table.delete = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return _delete.apply(null, args);
+	};
 	table.cascadeDelete = function(context, ...rest) {
 		const args = [context, table, ...rest];
 		return cascadeDelete.apply(null, args);