remult 0.26.16-next.0 → 0.26.17

package/esm/remult-duckdb.js

@@ -0,0 +1,116 @@
+import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
+import { ValueConverters, dbNamesOf, } from './index.js';
+import { shouldNotCreateField } from './src/filter/filter-consumer-bridge-to-sql-request.js';
+import { isAutoIncrement } from './src/remult3/RepositoryImplementation.js';
+export class DuckDBDataProvider extends SqliteCoreDataProvider {
+    constructor(db) {
+        super(() => new DuckDBCommand(db), async () => (await db).close(), false, true);
+    }
+    wrapIdentifier(name) {
+        return `"${name}"`;
+    }
+    async getCreateTableSql(entity) {
+        let result = '';
+        let e = await dbNamesOf(entity, this.wrapIdentifier);
+        let sql = '';
+        for (const x of entity.fields) {
+            if (!shouldNotCreateField(x, e) || isAutoIncrement(x)) {
+                if (result.length != 0)
+                    result += ',';
+                result += '\r\n  ';
+                if (isAutoIncrement(x)) {
+                    const sequenceName = `${entity.dbName}_${x.dbName}_seq`;
+                    sql += `create sequence if not exists "${sequenceName}";\r\n`;
+                    result += `${e.$dbNameOf(x)} integer default nextval('${sequenceName}')`;
+                }
+                else {
+                    result += this.addColumnSqlSyntax(x, e.$dbNameOf(x), false);
+                }
+            }
+        }
+        result += `,\r\n   primary key (${entity.idMetadata.fields
+            .map((f) => e.$dbNameOf(f))
+            .join(',')})`;
+        sql +=
+            'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
+        return sql;
+    }
+    addColumnSqlSyntax(x, dbName, isAlterColumn) {
+        let result = dbName;
+        var allowNull = x.allowNull;
+        if (allowNull && isAlterColumn) {
+            allowNull = false;
+            console.log('DuckDB does not support altering columns to allow null on existing tables');
+        }
+        if (x.valueType == Number) {
+            if (!x.valueConverter.fieldTypeInDb)
+                result += ' numeric' + (allowNull ? '' : ' default 0 not null');
+            else
+                result +=
+                    ' ' +
+                        x.valueConverter.fieldTypeInDb +
+                        (x.allowNull || isAlterColumn ? '' : ' default 0 not null');
+        }
+        else if (x.valueType == Date) {
+            if (!x.valueConverter.fieldTypeInDb)
+                if (x.valueConverter == ValueConverters.DateOnly)
+                    result += ' date';
+                else
+                    result += ' timestamp';
+            else
+                result += ' ' + x.valueConverter.fieldTypeInDb;
+        }
+        else if (x.valueType == Boolean)
+            result +=
+                ' boolean' +
+                    (x.allowNull || isAlterColumn ? '' : ' default false not null');
+        else if (x.valueConverter.fieldTypeInDb) {
+            result += ' ' + x.valueConverter.fieldTypeInDb;
+            if (!(x.allowNull || isAlterColumn) &&
+                x.valueConverter.fieldTypeInDb == 'integer') {
+                result += ' default 0 not null';
+            }
+        }
+        else
+            result +=
+                ' varchar' +
+                    (x.allowNull || isAlterColumn ? '' : " default '' not null");
+        return result;
+    }
+}
+class DuckDBCommand {
+    db;
+    values = [];
+    constructor(db) {
+        this.db = db;
+    }
+    async execute(sql) {
+        return new Promise((resolve, error) => {
+            this.db.all(sql, ...this.values, (err, rows) => {
+                if (err)
+                    error(err);
+                else
+                    resolve(new DuckDBSqlResult(rows));
+            });
+        });
+    }
+    addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
+        const key = '?';
+        this.values.push(val);
+        return key;
+    }
+}
+class DuckDBSqlResult {
+    result;
+    constructor(result) {
+        this.result = result;
+        this.rows = result;
+    }
+    rows;
+    getColumnKeyInResultForIndexInSelect(index) {
+        return Object.keys(this.result[0])[index];
+    }
+}

package/esm/remult-sqlite-core.js

@@ -5,10 +5,12 @@ export class SqliteCoreDataProvider {
     createCommand;
     end;
     doesNotSupportReturningSyntax;
-    constructor(createCommand, end, doesNotSupportReturningSyntax = false) {
+    doesNotSupportReturningSyntaxOnlyForUpdate;
+    constructor(createCommand, end, doesNotSupportReturningSyntax = false, doesNotSupportReturningSyntaxOnlyForUpdate = false) {
         this.createCommand = createCommand;
         this.end = end;
         this.doesNotSupportReturningSyntax = doesNotSupportReturningSyntax;
+        this.doesNotSupportReturningSyntaxOnlyForUpdate = doesNotSupportReturningSyntaxOnlyForUpdate;
     }
     orderByNullsFirst;
     getLimitSqlSyntax(limit, offset) {
@@ -23,7 +25,7 @@ export class SqliteCoreDataProvider {
             },
             addColumn: async (entity, field) => {
                 let e = await dbNamesOf(entity, this.wrapIdentifier);
-                let sql = `alter table ${e.$entityName} add column ${self.addColumnSqlSyntax(field, e.$dbNameOf(field))}`;
+                let sql = `alter table ${e.$entityName} add column ${self.addColumnSqlSyntax(field, e.$dbNameOf(field), true)}`;
                 builder.addSql(sql);
             },
         };
@@ -52,7 +54,7 @@ export class SqliteCoreDataProvider {
             console.info(sql);
         await this.createCommand().execute(sql);
     }
-    addColumnSqlSyntax(x, dbName) {
+    addColumnSqlSyntax(x, dbName, isAlterTable) {
         let result = dbName;
         const nullNumber = x.allowNull ? '' : ' default 0 not null';
         if (x.valueType == Date)
@@ -90,7 +92,7 @@ export class SqliteCoreDataProvider {
                     result += e.$dbNameOf(x) + ' integer primary key autoincrement';
                 }
                 else {
-                    result += this.addColumnSqlSyntax(x, e.$dbNameOf(x));
+                    result += this.addColumnSqlSyntax(x, e.$dbNameOf(x), false);
                     if (x.key == entity.idMetadata.field.key) {
                         result += ' primary key';
                     }

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

@@ -76,6 +76,9 @@ export class SqlDatabase {
                     supportsJsonColumnType: this.sql.supportsJsonColumnType,
                     wrapIdentifier: this.wrapIdentifier,
                     end: this.end,
+                    doesNotSupportReturningSyntax: this.sql.doesNotSupportReturningSyntax,
+                    doesNotSupportReturningSyntaxOnlyForUpdate: this.sql.doesNotSupportReturningSyntaxOnlyForUpdate,
+                    orderByNullsFirst: this.sql.orderByNullsFirst,
                 }));
             }
             finally {
@@ -344,11 +347,17 @@ class ActualSQLServerDataProvider {
         Filter.fromEntityFilter(this.entity, idFilter).__applyToConsumer(f);
         statement += await f.resolveWhere();
         let { colKeys, select } = this.buildSelect(e);
-        if (!this.sql._getSourceSql().doesNotSupportReturningSyntax)
+        let returning = true;
+        if (this.sql._getSourceSql().doesNotSupportReturningSyntax)
+            returning = false;
+        if (returning &&
+            this.sql._getSourceSql().doesNotSupportReturningSyntaxOnlyForUpdate)
+            returning = false;
+        if (returning)
             statement += ' returning ' + select;
         return r.execute(statement).then((sqlResult) => {
             this.sql._getSourceSql().afterMutation?.();
-            if (this.sql._getSourceSql().doesNotSupportReturningSyntax) {
+            if (!returning) {
                 return getRowAfterUpdate(this.entity, this, data, id, 'update');
             }
             if (sqlResult.rows.length != 1)

package/esm/src/remult3/remult3.js

@@ -1,6 +1,8 @@
 export const flags = {
     error500RetryCount: 4,
 };
+//y1 - 'test expression columns without aliases'
+//p1 - see if I can fix the no alias problem in selects
 //p1 - add luid - it's cool for order by.
 //p1 - replace uuid with crypto.randomUUID and allow custom fallback
 //p1 - add nanoid
@@ -11,6 +13,7 @@ export const flags = {
 //p1 - add LifecycleEvent to documentation
 //y1 - Talk about the case where we had one to many, without a field - just a filter - for example, event,event participants, users - and a field that shows all users that are not participants
 //p1 - Fix hagai and starter project to latest ts
+//y1 - talk about the $ sign in my filter rules - no other orm uses that (part of sql work, with $ etc)
 //y1 TODO - discuss next auth withRemult paradox - the gift that keeps on giving - it's doing something crazy there!!
 //p1 - fix chaining of saving and saved in multiple entity options args
 //p1 - review starter and examples and separate remult * auth from the routes

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.26.16-next.0",
+    "version": "0.26.17",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {
@@ -121,6 +121,11 @@
             "import": "./esm/remult-turso.js",
             "types": "./remult-turso.d.ts"
         },
+        "./remult-duckdb": {
+            "require": "./remult-duckdb.js",
+            "import": "./esm/remult-duckdb.js",
+            "types": "./remult-duckdb.d.ts"
+        },
         "./remult-bun-sqlite": {
             "require": "./remult-bun-sqlite.js",
             "import": "./esm/remult-bun-sqlite.js",

package/remult-duckdb.d.ts

@@ -0,0 +1,9 @@
+import type { Database } from 'duckdb';
+import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
+import { type FieldMetadata, type EntityMetadata } from './index.js';
+export declare class DuckDBDataProvider extends SqliteCoreDataProvider {
+    constructor(db: Database);
+    wrapIdentifier(name: string): string;
+    getCreateTableSql(entity: EntityMetadata<any>): Promise<string>;
+    addColumnSqlSyntax(x: FieldMetadata, dbName: string, isAlterColumn: boolean): string;
+}

package/remult-duckdb.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBDataProvider = void 0;
+var tslib_1 = require("tslib");
+var remult_sqlite_core_js_1 = require("./remult-sqlite-core.js");
+var index_js_1 = require("./index.js");
+var filter_consumer_bridge_to_sql_request_js_1 = require("./src/filter/filter-consumer-bridge-to-sql-request.js");
+var RepositoryImplementation_js_1 = require("./src/remult3/RepositoryImplementation.js");
+var DuckDBDataProvider = /** @class */ (function (_super) {
+    tslib_1.__extends(DuckDBDataProvider, _super);
+    function DuckDBDataProvider(db) {
+        var _this = _super.call(this, function () { return new DuckDBCommand(db); }, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, db];
+                case 1: return [2 /*return*/, (_a.sent()).close()];
+            }
+        }); }); }, false, true) || this;
+        return _this;
+    }
+    DuckDBDataProvider.prototype.wrapIdentifier = function (name) {
+        return "\"".concat(name, "\"");
+    };
+    DuckDBDataProvider.prototype.getCreateTableSql = function (entity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var result, e, sql, _a, _b, x, sequenceName;
+            var e_1, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        result = '';
+                        return [4 /*yield*/, (0, index_js_1.dbNamesOf)(entity, this.wrapIdentifier)];
+                    case 1:
+                        e = _d.sent();
+                        sql = '';
+                        try {
+                            for (_a = tslib_1.__values(entity.fields), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                x = _b.value;
+                                if (!(0, filter_consumer_bridge_to_sql_request_js_1.shouldNotCreateField)(x, e) || (0, RepositoryImplementation_js_1.isAutoIncrement)(x)) {
+                                    if (result.length != 0)
+                                        result += ',';
+                                    result += '\r\n  ';
+                                    if ((0, RepositoryImplementation_js_1.isAutoIncrement)(x)) {
+                                        sequenceName = "".concat(entity.dbName, "_").concat(x.dbName, "_seq");
+                                        sql += "create sequence if not exists \"".concat(sequenceName, "\";\r\n");
+                                        result += "".concat(e.$dbNameOf(x), " integer default nextval('").concat(sequenceName, "')");
+                                    }
+                                    else {
+                                        result += this.addColumnSqlSyntax(x, e.$dbNameOf(x), false);
+                                    }
+                                }
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        result += ",\r\n   primary key (".concat(entity.idMetadata.fields
+                            .map(function (f) { return e.$dbNameOf(f); })
+                            .join(','), ")");
+                        sql +=
+                            'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
+                        return [2 /*return*/, sql];
+                }
+            });
+        });
+    };
+    DuckDBDataProvider.prototype.addColumnSqlSyntax = function (x, dbName, isAlterColumn) {
+        var result = dbName;
+        var allowNull = x.allowNull;
+        if (allowNull && isAlterColumn) {
+            allowNull = false;
+            console.log('DuckDB does not support altering columns to allow null on existing tables');
+        }
+        if (x.valueType == Number) {
+            if (!x.valueConverter.fieldTypeInDb)
+                result += ' numeric' + (allowNull ? '' : ' default 0 not null');
+            else
+                result +=
+                    ' ' +
+                        x.valueConverter.fieldTypeInDb +
+                        (x.allowNull || isAlterColumn ? '' : ' default 0 not null');
+        }
+        else if (x.valueType == Date) {
+            if (!x.valueConverter.fieldTypeInDb)
+                if (x.valueConverter == index_js_1.ValueConverters.DateOnly)
+                    result += ' date';
+                else
+                    result += ' timestamp';
+            else
+                result += ' ' + x.valueConverter.fieldTypeInDb;
+        }
+        else if (x.valueType == Boolean)
+            result +=
+                ' boolean' +
+                    (x.allowNull || isAlterColumn ? '' : ' default false not null');
+        else if (x.valueConverter.fieldTypeInDb) {
+            result += ' ' + x.valueConverter.fieldTypeInDb;
+            if (!(x.allowNull || isAlterColumn) &&
+                x.valueConverter.fieldTypeInDb == 'integer') {
+                result += ' default 0 not null';
+            }
+        }
+        else
+            result +=
+                ' varchar' +
+                    (x.allowNull || isAlterColumn ? '' : " default '' not null");
+        return result;
+    };
+    return DuckDBDataProvider;
+}(remult_sqlite_core_js_1.SqliteCoreDataProvider));
+exports.DuckDBDataProvider = DuckDBDataProvider;
+var DuckDBCommand = /** @class */ (function () {
+    function DuckDBCommand(db) {
+        this.db = db;
+        this.values = [];
+    }
+    DuckDBCommand.prototype.execute = function (sql) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve, error) {
+                        var _a;
+                        (_a = _this.db).all.apply(_a, tslib_1.__spreadArray(tslib_1.__spreadArray([sql], tslib_1.__read(_this.values), false), [function (err, rows) {
+                                if (err)
+                                    error(err);
+                                else
+                                    resolve(new DuckDBSqlResult(rows));
+                            }], false));
+                    })];
+            });
+        });
+    };
+    DuckDBCommand.prototype.addParameterAndReturnSqlToken = function (val) {
+        return this.param(val);
+    };
+    DuckDBCommand.prototype.param = function (val) {
+        var key = '?';
+        this.values.push(val);
+        return key;
+    };
+    return DuckDBCommand;
+}());
+var DuckDBSqlResult = /** @class */ (function () {
+    function DuckDBSqlResult(result) {
+        this.result = result;
+        this.rows = result;
+    }
+    DuckDBSqlResult.prototype.getColumnKeyInResultForIndexInSelect = function (index) {
+        return Object.keys(this.result[0])[index];
+    };
+    return DuckDBSqlResult;
+}());

package/remult-sqlite-core.d.ts

@@ -1,11 +1,13 @@
 import type { EntityMetadata } from './src/remult3/remult3.js';
 import type { SqlCommand, SqlImplementation } from './src/sql-command.js';
+import type { FieldMetadata } from './src/column-interfaces.js';
 import type { CanBuildMigrations, MigrationBuilder, MigrationCode } from './migrations/migration-types.js';
 export declare class SqliteCoreDataProvider implements SqlImplementation, CanBuildMigrations {
     createCommand: () => SqlCommand;
     end: () => Promise<void>;
     doesNotSupportReturningSyntax: boolean;
-    constructor(createCommand: () => SqlCommand, end: () => Promise<void>, doesNotSupportReturningSyntax?: boolean);
+    doesNotSupportReturningSyntaxOnlyForUpdate: boolean;
+    constructor(createCommand: () => SqlCommand, end: () => Promise<void>, doesNotSupportReturningSyntax?: boolean, doesNotSupportReturningSyntaxOnlyForUpdate?: boolean);
     orderByNullsFirst?: boolean;
     getLimitSqlSyntax(limit: number, offset: number): string;
     afterMutation?: VoidFunction;
@@ -14,9 +16,9 @@ export declare class SqliteCoreDataProvider implements SqlImplementation, CanBui
     entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
     ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
     dropTable(entity: EntityMetadata): Promise<void>;
-    private addColumnSqlSyntax;
+    addColumnSqlSyntax(x: FieldMetadata, dbName: string, isAlterTable: boolean): string;
     createTableIfNotExist(entity: EntityMetadata<any>): Promise<void>;
     supportsJsonColumnType?: boolean;
-    private getCreateTableSql;
+    getCreateTableSql(entity: EntityMetadata<any>): Promise<string>;
     wrapIdentifier(name: string): string;
 }

package/remult-sqlite-core.js

@@ -6,11 +6,13 @@ var sql_database_js_1 = require("./src/data-providers/sql-database.js");
 var filter_consumer_bridge_to_sql_request_js_1 = require("./src/filter/filter-consumer-bridge-to-sql-request.js");
 var RepositoryImplementation_js_1 = require("./src/remult3/RepositoryImplementation.js");
 var SqliteCoreDataProvider = /** @class */ (function () {
-    function SqliteCoreDataProvider(createCommand, end, doesNotSupportReturningSyntax) {
+    function SqliteCoreDataProvider(createCommand, end, doesNotSupportReturningSyntax, doesNotSupportReturningSyntaxOnlyForUpdate) {
         if (doesNotSupportReturningSyntax === void 0) { doesNotSupportReturningSyntax = false; }
+        if (doesNotSupportReturningSyntaxOnlyForUpdate === void 0) { doesNotSupportReturningSyntaxOnlyForUpdate = false; }
         this.createCommand = createCommand;
         this.end = end;
         this.doesNotSupportReturningSyntax = doesNotSupportReturningSyntax;
+        this.doesNotSupportReturningSyntaxOnlyForUpdate = doesNotSupportReturningSyntaxOnlyForUpdate;
     }
     SqliteCoreDataProvider.prototype.getLimitSqlSyntax = function (limit, offset) {
         return ' limit ' + limit + ' offset ' + offset;
@@ -39,7 +41,7 @@ var SqliteCoreDataProvider = /** @class */ (function () {
                         case 0: return [4 /*yield*/, (0, filter_consumer_bridge_to_sql_request_js_1.dbNamesOf)(entity, this.wrapIdentifier)];
                         case 1:
                             e = _a.sent();
-                            sql = "alter table ".concat(e.$entityName, " add column ").concat(self.addColumnSqlSyntax(field, e.$dbNameOf(field)));
+                            sql = "alter table ".concat(e.$entityName, " add column ").concat(self.addColumnSqlSyntax(field, e.$dbNameOf(field), true));
                             builder.addSql(sql);
                             return [2 /*return*/];
                     }
@@ -136,7 +138,7 @@ var SqliteCoreDataProvider = /** @class */ (function () {
             });
         });
     };
-    SqliteCoreDataProvider.prototype.addColumnSqlSyntax = function (x, dbName) {
+    SqliteCoreDataProvider.prototype.addColumnSqlSyntax = function (x, dbName, isAlterTable) {
         var result = dbName;
         var nullNumber = x.allowNull ? '' : ' default 0 not null';
         if (x.valueType == Date)
@@ -195,7 +197,7 @@ var SqliteCoreDataProvider = /** @class */ (function () {
                                         result += e.$dbNameOf(x) + ' integer primary key autoincrement';
                                     }
                                     else {
-                                        result += this.addColumnSqlSyntax(x, e.$dbNameOf(x));
+                                        result += this.addColumnSqlSyntax(x, e.$dbNameOf(x), false);
                                         if (x.key == entity.idMetadata.field.key) {
                                             result += ' primary key';
                                         }

package/remult-turso.d.ts

@@ -1,4 +1,4 @@
-import { SqlImplementation } from './index.js';
+import type { SqlImplementation } from './index.js';
 import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
 import type { Client } from '@libsql/client';
 export declare class TursoDataProvider extends SqliteCoreDataProvider {

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

@@ -136,6 +136,9 @@ var SqlDatabase = /** @class */ (function () {
                                 supportsJsonColumnType: this.sql.supportsJsonColumnType,
                                 wrapIdentifier: this.wrapIdentifier,
                                 end: this.end,
+                                doesNotSupportReturningSyntax: this.sql.doesNotSupportReturningSyntax,
+                                doesNotSupportReturningSyntaxOnlyForUpdate: this.sql.doesNotSupportReturningSyntaxOnlyForUpdate,
+                                orderByNullsFirst: this.sql.orderByNullsFirst,
                             }))];
                     case 2:
                         _a.sent();
@@ -474,7 +477,7 @@ var ActualSQLServerDataProvider = /** @class */ (function () {
     };
     ActualSQLServerDataProvider.prototype.update = function (id, data) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var e, r, statement, added, _a, _b, x, v, idFilter, f, _c, _d, colKeys, select;
+            var e, r, statement, added, _a, _b, x, v, idFilter, f, _c, _d, colKeys, select, returning;
             var e_5, _e;
             var _this = this;
             return tslib_1.__generator(this, function (_f) {
@@ -517,12 +520,18 @@ var ActualSQLServerDataProvider = /** @class */ (function () {
                     case 2:
                         statement = _c + _f.sent();
                         _d = this.buildSelect(e), colKeys = _d.colKeys, select = _d.select;
-                        if (!this.sql._getSourceSql().doesNotSupportReturningSyntax)
+                        returning = true;
+                        if (this.sql._getSourceSql().doesNotSupportReturningSyntax)
+                            returning = false;
+                        if (returning &&
+                            this.sql._getSourceSql().doesNotSupportReturningSyntaxOnlyForUpdate)
+                            returning = false;
+                        if (returning)
                             statement += ' returning ' + select;
                         return [2 /*return*/, r.execute(statement).then(function (sqlResult) {
                                 var _a, _b;
                                 (_b = (_a = _this.sql._getSourceSql()).afterMutation) === null || _b === void 0 ? void 0 : _b.call(_a);
-                                if (_this.sql._getSourceSql().doesNotSupportReturningSyntax) {
+                                if (!returning) {
                                     return getRowAfterUpdate(_this.entity, _this, data, id, 'update');
                                 }
                                 if (sqlResult.rows.length != 1)

package/src/remult3/remult3.js

@@ -4,6 +4,8 @@ exports.flags = void 0;
 exports.flags = {
     error500RetryCount: 4,
 };
+//y1 - 'test expression columns without aliases'
+//p1 - see if I can fix the no alias problem in selects
 //p1 - add luid - it's cool for order by.
 //p1 - replace uuid with crypto.randomUUID and allow custom fallback
 //p1 - add nanoid
@@ -14,6 +16,7 @@ exports.flags = {
 //p1 - add LifecycleEvent to documentation
 //y1 - Talk about the case where we had one to many, without a field - just a filter - for example, event,event participants, users - and a field that shows all users that are not participants
 //p1 - Fix hagai and starter project to latest ts
+//y1 - talk about the $ sign in my filter rules - no other orm uses that (part of sql work, with $ etc)
 //y1 TODO - discuss next auth withRemult paradox - the gift that keeps on giving - it's doing something crazy there!!
 //p1 - fix chaining of saving and saved in multiple entity options args
 //p1 - review starter and examples and separate remult * auth from the routes

package/src/sql-command.d.ts

@@ -8,6 +8,7 @@ export interface SqlImplementation extends HasWrapIdentifier {
     supportsJsonColumnType?: boolean;
     /** true by default */
     doesNotSupportReturningSyntax?: boolean;
+    doesNotSupportReturningSyntaxOnlyForUpdate?: boolean;
     orderByNullsFirst?: boolean;
     end(): Promise<void>;
     afterMutation?: VoidFunction;