remult 3.4.0-next.5 → 3.4.0-next.6

package/SseSubscriptionServer.d.ts

@@ -1,10 +1,12 @@
 import type { GenericResponse } from './server/index.js';
+import type { SubscriptionServerRouteApi } from './server/remult-api-server.js';
 import type { Remult } from './src/context.js';
 import type { SubscriptionServer } from './src/live-query/SubscriptionServer.js';
 /** Keep below typical proxy idle (30s) and Heroku H15 (55s). */
 export declare const ssePingMs = 15000;
 export declare class SseSubscriptionServer implements SubscriptionServer {
     private canUserConnectToChannel?;
+    initApiServer(api: SubscriptionServerRouteApi): void;
     constructor(canUserConnectToChannel?: ((channel: string, remult: Remult) => boolean) | undefined);
     publishMessage<T>(channel: string, message: any): Promise<void>;
 }

package/SseSubscriptionServer.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.clientConnection = exports.SseSubscriptionServer = exports.ssePingMs = void 0;
 var tslib_1 = require("tslib");
 var SseSubscriptionClient_js_1 = require("./src/live-query/SseSubscriptionClient.js");
+var SubscriptionChannel_js_1 = require("./src/live-query/SubscriptionChannel.js");
 /** Keep below typical proxy idle (30s) and Heroku H15 (55s). */
 exports.ssePingMs = 15000;
 var SseSubscriptionServer = /** @class */ (function () {
@@ -18,6 +19,45 @@ var SseSubscriptionServer = /** @class */ (function () {
             this.canUserConnectToChannel = function () { return true; };
         }
     }
+    SseSubscriptionServer.prototype.initApiServer = function (api) {
+        var _this = this;
+        var streamPath = '/' + SubscriptionChannel_js_1.streamUrl;
+        api.addRoute(streamPath, 'get', function (_a) { return tslib_1.__awaiter(_this, [_a], void 0, function (_b) {
+            var req = _b.req, origRes = _b.origRes;
+            return tslib_1.__generator(this, function (_c) {
+                this.openHttpServerStream(req, origRes);
+                return [2 /*return*/];
+            });
+        }); });
+        api.addRoute(streamPath + '/subscribe', 'post', function (_a) { return tslib_1.__awaiter(_this, [_a], void 0, function (_b) {
+            var _c;
+            var remult = _b.remult, res = _b.res, getBody = _b.getBody;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _c = this.subscribeToChannel;
+                        return [4 /*yield*/, getBody()];
+                    case 1:
+                        _c.apply(this, [_d.sent(), res, remult]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        api.addRoute(streamPath + '/unsubscribe', 'post', function (_a) { return tslib_1.__awaiter(_this, [_a], void 0, function (_b) {
+            var _c;
+            var remult = _b.remult, res = _b.res, getBody = _b.getBody;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _c = this.subscribeToChannel;
+                        return [4 /*yield*/, getBody()];
+                    case 1:
+                        _c.apply(this, [_d.sent(), res, remult, true]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    };
     //@internal
     SseSubscriptionServer.prototype.subscribeToChannel = function (_a, res, remult, remove) {
         var e_1, _b;

package/esm/SseSubscriptionServer.js

@@ -1,8 +1,21 @@
 import { ConnectionNotFoundError } from './src/live-query/SseSubscriptionClient.js';
+import { streamUrl } from './src/live-query/SubscriptionChannel.js';
 /** Keep below typical proxy idle (30s) and Heroku H15 (55s). */
 export const ssePingMs = 15_000;
 export class SseSubscriptionServer {
     canUserConnectToChannel;
+    initApiServer(api) {
+        const streamPath = '/' + streamUrl;
+        api.addRoute(streamPath, 'get', async ({ req, origRes }) => {
+            this.openHttpServerStream(req, origRes);
+        });
+        api.addRoute(streamPath + '/subscribe', 'post', async ({ remult, res, getBody }) => {
+            this.subscribeToChannel(await getBody(), res, remult);
+        });
+        api.addRoute(streamPath + '/unsubscribe', 'post', async ({ remult, res, getBody }) => {
+            this.subscribeToChannel(await getBody(), res, remult, true);
+        });
+    }
     //@internal
     subscribeToChannel({ channel, clientId }, res, remult, remove = false) {
         for (const c of this.connections) {

package/esm/remult-mongo.js

@@ -119,6 +119,8 @@ class MongoEntityDataProvider {
     translateToDb(row, nameProvider) {
         let result = {};
         for (const col of this.entity.fields) {
+            if (col.dbReadOnly || col.isServerExpression)
+                continue;
             let val = toDb(col, row[col.key]);
             if (val === null)
                 val = NULL;
@@ -255,7 +257,7 @@ class MongoEntityDataProvider {
         for (const f of this.entity.fields) {
             if (!f.dbReadOnly && !f.isServerExpression) {
                 if (keys.includes(f.key)) {
-                    newR[f.key] = toDb(f, data[f.key]);
+                    newR[e.$dbNameOf(f)] = toDb(f, data[f.key]);
                 }
             }
         }
@@ -386,23 +388,27 @@ class FilterConsumerBridgeToMongo {
         this.add(col, val, '$lt');
     }
     containsCaseInsensitive(col, val) {
-        this.add(col, val, '$regex', { $options: 'i' });
+        this.addRegex(col, val);
     }
     notContainsCaseInsensitive(col, val) {
-        this.result.push(() => ({
-            [this.nameProvider.$dbNameOf(col)]: {
-                $not: {
-                    $regex: isNull(val) ? val : toDb(col, val),
-                    $options: 'i',
-                },
-            },
-        }));
+        this.addRegex(col, val, '', '', true);
     }
     startsWithCaseInsensitive(col, val) {
-        this.add(col, `^${val}`, '$regex', { $options: 'i' });
+        this.addRegex(col, val, '^');
     }
     endsWithCaseInsensitive(col, val) {
-        this.add(col, `${val}$`, '$regex', { $options: 'i' });
+        this.addRegex(col, val, '', '$');
+    }
+    addRegex(col, val, start = '', end = '', negate = false) {
+        this.result.push(() => {
+            const regex = {
+                $regex: start + toDb(col, val).replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + end,
+                $options: 'i',
+            };
+            return {
+                [this.nameProvider.$dbNameOf(col)]: negate ? { $not: regex } : regex,
+            };
+        });
     }
     add(col, val, operator, moreOptions) {
         this.result.push(() => ({

package/esm/server/remult-api-server.js

@@ -2,7 +2,7 @@ import { __decorate, __metadata } from "tslib";
 import { SseSubscriptionServer } from '../SseSubscriptionServer.js';
 import { Remult, RemultAsyncLocalStorage, withRemult } from '../src/context.js';
 import { DataApi, serializeError } from '../src/data-api.js';
-import { liveQueryKeepAliveRoute, streamUrl, } from '../src/live-query/SubscriptionChannel.js';
+import { liveQueryKeepAliveRoute } from '../src/live-query/SubscriptionChannel.js';
 import { InMemoryLiveQueryStorage, LiveQueryPublisher, } from '../src/live-query/SubscriptionServer.js';
 import { IdEntity } from '../src/remult3/IdEntity.js';
 import { Fields } from '../src/remult3/Fields.js';
@@ -266,19 +266,20 @@ export class RemultServerImplementation {
                 r.route(this.options.rootPath + '/admin').get(admin());
             }
             r.route(this.options.rootPath + '/me').get(this.process(async (remult, req, res) => res.success(remult.user ?? null)));
-            if (this.options.subscriptionServer instanceof SseSubscriptionServer) {
-                const streamPath = this.options.rootPath + '/' + streamUrl;
-                r.route(streamPath).get(this.process(async (remult, req, res, origReq, origRes) => {
-                    ;
-                    remult.subscriptionServer.openHttpServerStream(origReq, origRes);
-                }));
-                r.route(streamPath + '/subscribe').post(this.process(async (remult, _2, res, _, _1, origReq) => {
-                    const body = remult.subscriptionServer.subscribeToChannel(await this.coreOptions.getRequestBody(origReq), res, remult);
-                }));
-                r.route(streamPath + '/unsubscribe').post(this.process(async (remult, req, res, reqInfo, origRes, origReq) => {
-                    ;
-                    remult.subscriptionServer.subscribeToChannel(await this.coreOptions.getRequestBody(origReq), res, remult, true);
-                }));
+            const subscriptionServer = this.options.subscriptionServer;
+            if (subscriptionServer?.initApiServer) {
+                subscriptionServer.initApiServer({
+                    rootPath: this.options.rootPath,
+                    addRoute: (relativePath, method, handler) => {
+                        r.route(this.options.rootPath + relativePath)[method](this.process(async (remult, _, res, req, origRes, origReq) => handler({
+                            remult,
+                            res,
+                            req,
+                            origRes,
+                            getBody: () => this.coreOptions.getRequestBody(origReq),
+                        })));
+                    },
+                });
             }
             r.route(this.options.rootPath + '/' + liveQueryKeepAliveRoute).post(this.process(async (remult, req, res, reqInfo, origRes, origReq) => {
                 const body = await this.coreOptions.getRequestBody(origReq);

package/esm/src/data-api.js

@@ -12,7 +12,7 @@ export class DataApi {
         this.repository = repository;
         this.remult = remult;
     }
-    httpGet(res, req, serializeContext) {
+    async httpGet(res, req, serializeContext) {
         try {
             const action = req?.get('__action');
             if (action?.startsWith(liveQueryAction))
@@ -22,13 +22,13 @@ export class DataApi {
                 case 'count':
                     return this.count(res, req, undefined);
                 case 'groupBy':
-                    return res.success(this.groupBy(req, undefined));
+                    return res.success(await this.groupBy(req, undefined));
             }
             return this.getArray(res, req, undefined);
         }
         catch (err) {
             if (err.isForbiddenError)
-                res.forbidden(err);
+                res.forbidden(err.message);
             else
                 res.error(err, this.repository.metadata);
         }
@@ -70,7 +70,7 @@ export class DataApi {
                     res.success('ok');
                     return;
                 case 'query':
-                    return res.success(await this.query(res, req, body));
+                    return this.query(res, req, body);
                 default:
                     return res.created(await this.post(body, req));
             }
@@ -124,10 +124,10 @@ export class DataApi {
                 this.getArrayImpl(request, rest),
                 this.groupBy(aggregateRequest, { ...aggregate, where: body.where }),
             ]);
-            return {
+            return response.success({
                 items: r,
                 aggregates,
-            };
+            });
         }
         catch (err) {
             if (err.isForbiddenError)

package/esm/src/data-providers/sql-database.js

@@ -159,6 +159,34 @@ export class SqlDatabase {
         await (await getRepositoryInternals(r)._translateWhereToFilter(condition)).__applyToConsumer(b);
         return await b.resolveWhere();
     }
+    /**
+     * Builds the select that `repo.groupBy` would run, without running it - for a statement remult cannot run on its own, such as one `UNION ALL` over several databases.
+     * @returns `sql`, and `toResult`, which maps a result row (read by column alias) to the shape `groupBy` returns.
+     * @see [Building a select with remult](https://remult.dev/docs/running-sql-on-the-server#building-a-select-with-remult)
+     */
+    static async groupByToRaw(repo, options, sql) {
+        const r = getRepository(repo);
+        const built = await buildGroupBySql(await getRepositoryInternals(r).__buildGroupByOptions(options), sql?.dbNames ??
+            (await dbNamesOfWithForceSqlExpression(r.metadata, sql?.wrapIdentifier ?? wrapIdentifierOf(r))), sql?.sqlCommand ?? new myDummySQLCommand(), false, sql?.limitSyntax ?? limitSyntaxRequired);
+        return {
+            sql: built.select,
+            toResult: (row) => built.toResult((_, alias) => row[alias]),
+        };
+    }
+    /**
+     * Builds the select that `repo.find` would run, without running it. Columns are aliased by field key; no default order is added, so the sql can be a branch of a `UNION`.
+     * @returns `sql`, and `toResult`, which maps a result row (read by column alias) to the fields' values.
+     * @see [Building a select with remult](https://remult.dev/docs/running-sql-on-the-server#building-a-select-with-remult)
+     */
+    static async selectToRaw(repo, options, sql) {
+        const r = getRepository(repo);
+        const built = await buildFindSql(r.metadata, await getRepositoryInternals(r)._buildEntityDataProviderFindOptions(options ?? {}), sql?.dbNames ??
+            (await dbNamesOfWithForceSqlExpression(r.metadata, sql?.wrapIdentifier ?? wrapIdentifierOf(r))), sql?.sqlCommand ?? new myDummySQLCommand(), false, sql?.limitSyntax ?? limitSyntaxRequired, { aliasColumns: true, defaultOrderBy: false });
+        return {
+            sql: built.select,
+            toResult: (row) => built.toResult((_, alias) => row[alias]),
+        };
+    }
     /**
      * `false` _(default)_ - No logging
      *
@@ -323,105 +351,17 @@ class ActualSQLEntityDataProvider {
         return await groupByImpl(options, await this.init(), this.sql.createCommand(), this.sql._getSourceSql().orderByNullsFirst, this.sql._getSourceSql().getLimitSqlSyntax);
     }
     async find(options) {
-        let e = await this.init();
-        let r = this.sql.createCommand();
-        let { colKeys, select } = await this.buildSelect(e, r, options?.select, options?.args);
-        select = 'select ' + select;
-        select += '\n from ' + e.$entityName;
-        if (options) {
-            if (options.where) {
-                let where = new FilterConsumerBridgeToSqlRequest(r, e);
-                options.where.__applyToConsumer(where);
-                select += await where.resolveWhere();
-            }
-            if (options.limit) {
-                options.orderBy = Sort.createUniqueSort(this.entity, options.orderBy);
-            }
-            if (!options.orderBy) {
-                options.orderBy = Sort.createUniqueSort(this.entity, new Sort());
-            }
-            if (options.orderBy) {
-                let first = true;
-                let segs = [];
-                for (const s of options.orderBy.Segments) {
-                    segs.push(s);
-                }
-                for (const c of segs) {
-                    if (first) {
-                        select += ' Order By ';
-                        first = false;
-                    }
-                    else
-                        select += ', ';
-                    select += c.field.options.sqlExpression
-                        ? c.field.options.key
-                        : await e.$dbNameOf(c.field);
-                    if (c.isDescending)
-                        select += ' desc';
-                    if (this.sql._getSourceSql().orderByNullsFirst) {
-                        if (c.isDescending)
-                            select += ' nulls last';
-                        else
-                            select += ' nulls first';
-                    }
-                }
-            }
-            if (options.limit) {
-                let page = 1;
-                if (options.page)
-                    page = options.page;
-                if (page < 1)
-                    page = 1;
-                select +=
-                    ' ' +
-                        this.strategy.getLimitSqlSyntax(options.limit, (page - 1) * options.limit);
-            }
-        }
-        return r.execute(select).then((r) => {
-            return r.rows.map((y) => {
-                return this.buildResultRow(colKeys, y, r);
-            });
-        });
+        const e = await this.init();
+        const r = this.sql.createCommand();
+        const { select, toResult } = await buildFindSql(this.entity, options, e, r, this.sql._getSourceSql().orderByNullsFirst, (limit, offset) => this.strategy.getLimitSqlSyntax(limit, offset));
+        const result = await r.execute(select);
+        return result.rows.map((y) => toResult((i) => y[result.getColumnKeyInResultForIndexInSelect(i)]));
     }
     buildResultRow(colKeys, y, r) {
-        let result = {};
-        for (let index = 0; index < colKeys.length; index++) {
-            const col = colKeys[index];
-            try {
-                result[col.key] = col.valueConverter.fromDb(y[r.getColumnKeyInResultForIndexInSelect(index)]);
-            }
-            catch (err) {
-                throw new Error('Failed to load from db:' + col.key + '\r\n' + err);
-            }
-        }
-        return result;
+        return resultRow(colKeys, (i) => y[r.getColumnKeyInResultForIndexInSelect(i)]);
     }
     async buildSelect(e, r, selectedFields, args) {
-        let select = '';
-        let colKeys = [];
-        for (const x of this.entity.fields) {
-            if (selectedFields && !selectedFields.includes(x.key))
-                continue;
-            if (x.isServerExpression) {
-            }
-            else {
-                if (colKeys.length > 0)
-                    select += ', ';
-                if (typeof x.options.sqlExpression === 'function') {
-                    let sql = await x[originalSqlExpressionKey](this.entity, args, r);
-                    if (sql.includes(' '))
-                        select += '(' + sql + ')';
-                    else
-                        select += sql;
-                }
-                else
-                    select += e.$dbNameOf(x);
-                if (x.options.sqlExpression)
-                    select += ' as ' + x.key;
-                colKeys.push(x);
-            }
-        }
-        return { colKeys, select };
+        return selectColumns(this.entity, e, r, selectedFields, args, false);
     }
     async update(id, data, options) {
         let e = await this.init();
@@ -573,6 +513,16 @@ class ActualSQLEntityDataProvider {
         });
     }
 }
+/** The quoting of the repository's own data provider, so a raw select matches the SQL remult would run against it. */
+function wrapIdentifierOf(r) {
+    const dp = getRepositoryInternals(r)._dataProvider;
+    if (isOfType(dp, 'wrapIdentifier'))
+        return dp.wrapIdentifier?.bind(dp);
+    return undefined;
+}
+function limitSyntaxRequired() {
+    throw new Error('A raw select with a limit needs limitSyntax, for example SqlDatabase.getDb()._getSourceSql().getLimitSqlSyntax');
+}
 class myDummySQLCommand {
     execute(sql) {
         throw new Error('Method not implemented.');
@@ -609,8 +559,116 @@ export function getRowAfterUpdate(meta, dataProvider, data, id, operation) {
         return r[0];
     });
 }
+/** The select that `find` runs, and the mapping of one result row to field values. With `aliasColumns`, every column is aliased through `wrapIdentifier`, so a row can be read by alias as well as by position. */
+export async function buildFindSql(entity, options, e, r, orderByNullsFirst, limitSyntax, { aliasColumns = false, defaultOrderBy = true } = {}) {
+    const { colKeys, select: columns } = await selectColumns(entity, e, r, options?.select, options?.args, aliasColumns);
+    let select = 'select ' + columns + '\n from ' + e.$entityName;
+    if (options) {
+        if (options.where) {
+            let where = new FilterConsumerBridgeToSqlRequest(r, e);
+            options.where.__applyToConsumer(where);
+            select += await where.resolveWhere();
+        }
+        if (options.limit) {
+            options.orderBy = Sort.createUniqueSort(entity, options.orderBy);
+        }
+        if (!options.orderBy && defaultOrderBy) {
+            options.orderBy = Sort.createUniqueSort(entity, new Sort());
+        }
+        if (options.orderBy) {
+            let first = true;
+            for (const c of options.orderBy.Segments) {
+                if (first) {
+                    select += ' Order By ';
+                    first = false;
+                }
+                else
+                    select += ', ';
+                select += c.field.options.sqlExpression
+                    ? c.field.options.key
+                    : await e.$dbNameOf(c.field);
+                if (c.isDescending)
+                    select += ' desc';
+                if (orderByNullsFirst) {
+                    if (c.isDescending)
+                        select += ' nulls last';
+                    else
+                        select += ' nulls first';
+                }
+            }
+        }
+        if (options.limit) {
+            let page = 1;
+            if (options.page)
+                page = options.page;
+            if (page < 1)
+                page = 1;
+            select += ' ' + limitSyntax(options.limit, (page - 1) * options.limit);
+        }
+    }
+    return {
+        select,
+        colKeys,
+        /** `valueAt` reads one column of a result row, by its position in the select or by its alias (the field key). */
+        toResult(valueAt) {
+            return resultRow(colKeys, valueAt);
+        },
+    };
+}
+async function selectColumns(entity, e, r, selectedFields, args, aliasColumns) {
+    let select = '';
+    let colKeys = [];
+    for (const x of entity.fields) {
+        if (selectedFields && !selectedFields.includes(x.key))
+            continue;
+        if (x.isServerExpression) {
+        }
+        else {
+            if (colKeys.length > 0)
+                select += ', ';
+            if (typeof x.options.sqlExpression === 'function') {
+                let sql = await x[originalSqlExpressionKey](entity, args, r);
+                if (sql.includes(' '))
+                    select += '(' + sql + ')';
+                else
+                    select += sql;
+            }
+            else
+                select += e.$dbNameOf(x);
+            if (aliasColumns)
+                select += ' as ' + e.wrapIdentifier(x.key);
+            else if (x.options.sqlExpression)
+                select += ' as ' + x.key;
+            colKeys.push(x);
+        }
+    }
+    return { colKeys, select };
+}
+function resultRow(colKeys, valueAt) {
+    let result = {};
+    colKeys.forEach((col, index) => {
+        try {
+            result[col.key] = col.valueConverter.fromDb(valueAt(index, col.key));
+        }
+        catch (err) {
+            throw new Error('Failed to load from db:' + col.key + '\r\n' + err);
+        }
+    });
+    return result;
+}
 export async function groupByImpl(options, e, r, orderByNullFirst, limitSyntax) {
-    let select = 'select count(*) as count';
+    const { select, toResult } = await buildGroupBySql(options, e, r, orderByNullFirst, limitSyntax);
+    const result = await r.execute(select);
+    return result.rows.map((sql) => toResult((i) => sql[result.getColumnKeyInResultForIndexInSelect(i)]));
+}
+/** The select that `groupBy` runs, and the mapping of one result row back to a `GroupByResult`. Every column is aliased through `wrapIdentifier`, so a row can be read by alias as well as by position. */
+export async function buildGroupBySql(options, e, r, orderByNullFirst, limitSyntax) {
+    const aliases = [];
+    function alias(name) {
+        aliases.push(name);
+        return e.wrapIdentifier(name);
+    }
+    let select = 'select count(*) as ' + alias('count');
     let groupBy = '';
     const groupByCols = [];
     const processResultRow = [];
@@ -622,9 +680,7 @@ export async function groupByImpl(options, e, r, orderByNullFirst, limitSyntax)
             if (x.isServerExpression) {
             }
             else {
-                select += ', ' + e.$dbNameOf(x);
-                if (x.options.sqlExpression)
-                    select += ' as ' + x.key;
+                select += ', ' + e.$dbNameOf(x) + ' as ' + alias(x.key);
                 if (groupBy == '')
                     groupBy = ' group by ';
                 else
@@ -644,7 +700,7 @@ export async function groupByImpl(options, e, r, orderByNullFirst, limitSyntax)
                 }
                 else {
                     const dbName = await e.$dbNameOf(x);
-                    select += `, ${aggregateSqlSyntax(operator, dbName)} as ${x.key}_${operator}`;
+                    select += `, ${aggregateSqlSyntax(operator, dbName)} as ${alias(x.key + '_' + operator)}`;
                 }
                 const turnToNumber = x.valueType === Number || operator == 'distinctCount';
                 processResultRow.push((sqlResult, theResult) => {
@@ -708,12 +764,15 @@ export async function groupByImpl(options, e, r, orderByNullFirst, limitSyntax)
             page = 1;
         select += ' ' + limitSyntax(options.limit, (page - 1) * options.limit);
     }
-    const result = await r.execute(select);
-    return result.rows.map((sql) => {
-        let theResult = {};
-        processResultRow.forEach((x, i) => x(sql[result.getColumnKeyInResultForIndexInSelect(i)], theResult));
-        return theResult;
-    });
+    return {
+        select,
+        /** `valueAt` reads one column of a result row, by its position in the select or by its alias. */
+        toResult(valueAt) {
+            let theResult = {};
+            processResultRow.forEach((x, i) => x(valueAt(i, aliases[i]), theResult));
+            return theResult;
+        },
+    };
     function aggregateSqlSyntax(operator, dbName) {
         return operator === 'distinctCount'
             ? `count (distinct ${dbName})`

package/esm/src/remult3/RepositoryImplementation.js

@@ -449,6 +449,8 @@ export class RepositoryImplementation {
             if (ref)
                 return returnResult((await ref.save(options)));
         }
+        if (id === undefined || id === null)
+            throw this._notFoundError(id);
         {
             let ref = getEntityRef(id, false);
             if (ref) {

package/index.d.ts

@@ -30,6 +30,7 @@ ValueOrExpression, } from './src/column-interfaces.js';
 export { RestDataProvider } from './src/data-providers/rest-data-provider.js';
 export { InMemoryDataProvider } from './src/data-providers/in-memory-database.js';
 export { SqlDatabase } from './src/data-providers/sql-database.js';
+export type { RawSelectOptions } from './src/data-providers/sql-database.js';
 export { CustomSqlFilterBuilder, dbNamesOf, } from './src/filter/filter-consumer-bridge-to-sql-request.js';
 export type { dbNamesOfOptions, CustomSqlFilterBuilderFunction, EntityDbNames, } from './src/filter/filter-consumer-bridge-to-sql-request.js';
 export { JsonDataProvider } from './src/data-providers/json-data-provider.js';

package/internals.d.ts

@@ -14,6 +14,8 @@ export declare const actionInfo: {
 };
 export { isOfType } from './src/isOfType.js';
 export type { ClassType } from './classType.js';
+export type { SubscriptionServerRouteApi, SubscriptionServerRouteHandlerArgs, } from './server/remult-api-server.js';
+export type { DataApiResponse } from './src/data-api.js';
 export { flags } from './src/remult3/remult3.js';
 export { SseSubscriptionClient } from './src/live-query/SseSubscriptionClient.js';
 export { DataProviderPromiseWrapper } from './src/data-interfaces.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "3.4.0-next.5",
+    "version": "3.4.0-next.6",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {

package/remult-mongo.js

@@ -228,6 +228,8 @@ var MongoEntityDataProvider = /** @class */ (function () {
         try {
             for (var _b = tslib_1.__values(this.entity.fields), _c = _b.next(); !_c.done; _c = _b.next()) {
                 var col = _c.value;
+                if (col.dbReadOnly || col.isServerExpression)
+                    continue;
                 var val = toDb(col, row[col.key]);
                 if (val === null)
                     val = NULL;
@@ -494,7 +496,7 @@ var MongoEntityDataProvider = /** @class */ (function () {
                                 f_1 = _c.value;
                                 if (!f_1.dbReadOnly && !f_1.isServerExpression) {
                                     if (keys.includes(f_1.key)) {
-                                        newR[f_1.key] = toDb(f_1, data[f_1.key]);
+                                        newR[e.$dbNameOf(f_1)] = toDb(f_1, data[f_1.key]);
                                     }
                                 }
                             }
@@ -797,27 +799,32 @@ var FilterConsumerBridgeToMongo = /** @class */ (function () {
         this.add(col, val, '$lt');
     };
     FilterConsumerBridgeToMongo.prototype.containsCaseInsensitive = function (col, val) {
-        this.add(col, val, '$regex', { $options: 'i' });
+        this.addRegex(col, val);
     };
     FilterConsumerBridgeToMongo.prototype.notContainsCaseInsensitive = function (col, val) {
-        var _this = this;
-        this.result.push(function () {
-            var _a;
-            return (_a = {},
-                _a[_this.nameProvider.$dbNameOf(col)] = {
-                    $not: {
-                        $regex: isNull(val) ? val : toDb(col, val),
-                        $options: 'i',
-                    },
-                },
-                _a);
-        });
+        this.addRegex(col, val, '', '', true);
     };
     FilterConsumerBridgeToMongo.prototype.startsWithCaseInsensitive = function (col, val) {
-        this.add(col, "^".concat(val), '$regex', { $options: 'i' });
+        this.addRegex(col, val, '^');
     };
     FilterConsumerBridgeToMongo.prototype.endsWithCaseInsensitive = function (col, val) {
-        this.add(col, "".concat(val, "$"), '$regex', { $options: 'i' });
+        this.addRegex(col, val, '', '$');
+    };
+    FilterConsumerBridgeToMongo.prototype.addRegex = function (col, val, start, end, negate) {
+        var _this = this;
+        if (start === void 0) { start = ''; }
+        if (end === void 0) { end = ''; }
+        if (negate === void 0) { negate = false; }
+        this.result.push(function () {
+            var _a;
+            var regex = {
+                $regex: start + toDb(col, val).replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + end,
+                $options: 'i',
+            };
+            return _a = {},
+                _a[_this.nameProvider.$dbNameOf(col)] = negate ? { $not: regex } : regex,
+                _a;
+        });
     };
     FilterConsumerBridgeToMongo.prototype.add = function (col, val, operator, moreOptions) {
         var _this = this;