orange-orm 5.1.0 → 5.2.0-beta.0

package/README.md

@@ -634,6 +634,8 @@ The following operators are supported:
 - max  
 - avg  
 
+For distinct rows across selected fields, you can use `table.distinct(...)`.
+
 You can also elevate associated data to a parent level for easier access. In the example below, <i>balance</i> of the customer is elevated to the root level.
 
 ```javascript
@@ -651,6 +653,19 @@ async function getRows() {
 }
 ```
 
+```javascript
+import map from './map';
+const db = map.sqlite('demo.db');
+
+getDistinct();
+
+async function getDistinct() {
+  const rows = await db.orderLine.distinct({
+    orderId: x => x.orderId
+  });
+}
+```
+
 __Many rows filtered__
 
 ```javascript
@@ -1150,7 +1165,7 @@ async function deleteRows() {
 </details>
 
 <details id="in-the-browser"><summary><strong>In the browser</strong></summary>
-<p>You can use <strong><i>Orange</i></strong> in the browser by using the adapter for Express. Instead of sending raw SQL queries from the client to the server, this approach records the method calls in the client. These method calls are then replayed at the server, ensuring a higher level of security by not exposing raw SQL on the client side.  
+<p>You can use <strong><i>Orange</i></strong> in the browser by using the adapter for Express or Hono. Instead of sending raw SQL queries from the client to the server, this approach records the method calls in the client. These method calls are then replayed at the server, ensuring a higher level of security by not exposing raw SQL on the client side.  
 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>
@@ -1197,6 +1212,32 @@ async function updateRows() {
 
 ```
 
+__Hono adapter__
+
+You can host the same HTTP endpoint with Hono by replacing `db.express()` with `db.hono()`. The browser client setup stays the same (`map.http(...)`), so you can reuse the `browser.ts` example above.
+
+<sub>📄 server.ts</sub>
+
+```ts
+import map from './map';
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { serve } from '@hono/node-server';
+
+const db = map.sqlite('demo.db');
+const app = new Hono();
+
+app.use('/orange', cors());
+app.use('/orange/*', cors());
+// for demonstrational purposes, authentication middleware is not shown here.
+app.all('/orange', db.hono());
+app.all('/orange/*', db.hono());
+
+serve({ fetch: app.fetch, port: 3000 });
+```
+
+`baseFilter` and transaction hooks are also supported in `db.hono({...})`, using Hono-style request/response objects.
+
 __Interceptors and base filter__
 
 In the next setup, axios interceptors are employed on the client side to add an Authorization header of requests. Meanwhile, on the server side, an Express middleware (validateToken) is utilized to ensure the presence of the Authorization header, while a base filter is applied on the order table to filter incoming requests based on the customerId extracted from this header. This combined approach enhances security by ensuring that users can only access data relevant to their authorization level and that every request is accompanied by a token. In real-world applications, it's advisable to use a more comprehensive token system and expand error handling to manage a wider range of potential issues.  
@@ -1563,6 +1604,33 @@ async function getRows() {
   });
 }
 ```
+__Column-to-column filters__  
+You can compare one column to another column instead of comparing to a constant value.  
+This works both on the same table and across relations.
+
+```javascript
+import map from './map';
+const db = map.sqlite('demo.db');
+
+getRows();
+
+async function getRows() {
+  // equality between related columns
+  const sameName = await db.order.getMany({
+    where: x => x.deliveryAddress.name.eq(x.customer.name)
+  });
+
+  // string pattern match against another column
+  const containsName = await db.order.getMany({
+    where: x => x.deliveryAddress.name.contains(x.customer.name)
+  });
+
+  // column as one of the bounds in between
+  const withColumnBound = await db.customer.getMany({
+    where: x => x.balance.between(x.id, 180)
+  });
+}
+```
 __In__  
 ```javascript
 import map from './map';
@@ -2247,6 +2315,24 @@ async function getAggregates() {
 }
 ```
 
+__Distinct__  
+Use `distinct` when you want unique combinations of selected fields.
+When only plain columns are selected, this uses SQL `DISTINCT`.
+If aggregate expressions are included, it falls back to `GROUP BY`.
+
+```javascript
+import map from './map';
+const db = map.sqlite('demo.db');
+
+getDistinctRows();
+
+async function getDistinctRows() {
+  const rows = await db.orderLine.distinct({
+    orderId: x => x.orderId
+  });
+}
+```
+
 __Count__  
 For convenience, you can use the <i>count</i> directly on the table instead of using the aggregated query syntax.
 ```javascript

package/bin/build.js

@@ -114,6 +114,7 @@ function findClosestPackageJson(startDir) {
 function findClosestNodeModules(startPath) {
 	const startDir = fs.statSync(startPath).isDirectory() ? startPath : path.dirname(startPath);
 	let currentDir = startDir;
+	// eslint-disable-next-line no-constant-condition
 	while (true) {
 		const nodeModulesPath = path.join(currentDir, 'node_modules');
 		if (fs.existsSync(nodeModulesPath))