remult 0.27.21-next.9 → 0.27.21

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

@@ -0,0 +1,125 @@
+import { dbNamesOf, } from '../filter/filter-consumer-bridge-to-sql-request.js';
+import { getRelationFieldInfo } from '../remult3/relationInfoMember.js';
+import { SqlDatabase } from './sql-database.js';
+import { remult } from '../remult-proxy.js';
+export function sqlRelations(forEntity) {
+    return new Proxy({}, {
+        get: (target, relationField) => new Proxy(new SqlRelationTools(forEntity, relationField), {
+            get: (target, prop) => {
+                if (prop == '$count')
+                    return target.$count;
+                if (prop == '$subQuery')
+                    return target.$subQuery;
+                if (prop == '$relations')
+                    return target.___relations();
+                if (prop == '$first')
+                    return target.$first;
+                return target.$fields[prop];
+            },
+        }),
+    });
+}
+class SqlRelationTools {
+    myEntity;
+    relationField;
+    constructor(myEntity, relationField) {
+        this.myEntity = myEntity;
+        this.relationField = relationField;
+    }
+    $count = (where) => {
+        return this.$subQuery(() => 'count(*)', { where });
+    };
+    $first = (options) => {
+        return new Proxy(this, {
+            get: (target, prop) => {
+                if (prop == '$subQuery')
+                    return (what) => target.$subQuery(what, { ...options, first: true });
+                if (prop == '$relations')
+                    return this.___relations({ ...options, first: true });
+                return target.$subQuery((fieldNamesOfToEntity) => fieldNamesOfToEntity.$dbNameOf(prop), { ...options, first: true });
+            },
+        });
+    };
+    $fields = new Proxy(this, {
+        get: (target, field) => {
+            return target.$subQuery((fieldNamesOfToEntity) => fieldNamesOfToEntity.$dbNameOf(field));
+        },
+    });
+    $subQuery = async (what, options) => {
+        const rel = getRelationFieldInfo(remult.repo(this.myEntity).fields.find(this.relationField));
+        if (!rel)
+            throw new Error(`${this.relationField} is not a relation`);
+        const relFields = rel.getFields();
+        const filters = [];
+        const namesOfOtherTable = await dbNamesOf(rel.toEntity, {
+            tableName: true,
+        });
+        const namesOfMyTable = await dbNamesOf(this.myEntity, { tableName: true });
+        for (const key in relFields.fields) {
+            if (Object.prototype.hasOwnProperty.call(relFields.fields, key)) {
+                filters.push(`${namesOfOtherTable.$dbNameOf(key)} = ${namesOfMyTable.$dbNameOf(relFields.fields[key])}`);
+            }
+        }
+        const otherTableFilter = await SqlDatabase.filterToRaw(remult.repo(rel.toEntity), 
+        // eslint-disable-next-line
+        options?.where, undefined, namesOfOtherTable);
+        if (otherTableFilter)
+            filters.push(otherTableFilter);
+        let result = `
+( SELECT ${await what(namesOfOtherTable)} 
+  FROM ${namesOfOtherTable} 
+  WHERE ${filters.join(' and ')}`;
+        if (options?.orderBy) {
+            result += `
+  ORDER BY ${Object.keys(options.orderBy)
+                .map((key) => `${namesOfOtherTable.$dbNameOf(key)} ${options.orderBy[key]}`)
+                .join(', ')}`;
+        }
+        if (options?.first) {
+            result += `
+  LIMIT 1`;
+        }
+        return (result +
+            `
+)`);
+    };
+    ___relations(options) {
+        return new Proxy(this, {
+            get: (target, field) => {
+                const rel1 = getRelationFieldInfo(remult.repo(this.myEntity).fields.find(this.relationField));
+                return new Proxy(this, {
+                    get: (target, field1) => {
+                        return this.$subQuery(() => indent(sqlRelations(rel1.toEntity)[field][field1]), options);
+                    },
+                });
+            },
+        });
+    }
+}
+export function sqlRelationsFilter(forEntity) {
+    return new Proxy({}, {
+        get: (target, relationField) => new SqlRelationFilter(forEntity, relationField),
+    });
+}
+export class SqlRelationFilter {
+    _tools;
+    constructor(myEntity, relationField) {
+        this._tools = new SqlRelationTools(myEntity, relationField);
+    }
+    some(where) {
+        //many orms use some, every, none
+        return SqlDatabase.rawFilter(async (c) => {
+            return ('exists ' +
+                (await this._tools.$subQuery(() => '1', {
+                    where,
+                    c,
+                })));
+        });
+    }
+}
+function indent(s) {
+    return s.then((s) => s
+        .split('\n')
+        .map((x) => '  ' + x)
+        .join('\n'));
+}

package/esm/src/remult-static.js

@@ -18,6 +18,7 @@ let x = {
             close: () => { },
         }),
     },
+    fieldOptionsEnricher: undefined,
     captionTransformer: undefined,
     defaultDataProvider: () => undefined,
 };

package/esm/src/remult3/RepositoryImplementation.js

@@ -1,6 +1,6 @@
 import { LookupColumn, makeTitle } from '../column.js';
 import { CompoundIdField } from '../CompoundIdField.js';
-import { Remult, isBackend } from '../context.js';
+import { Remult } from '../context.js';
 import { Filter } from '../filter/filter-interfaces.js';
 import { Sort } from '../sort.js';
 import { GroupByForApiKey, } from './remult3.js';
@@ -640,50 +640,69 @@ export class RepositoryImplementation {
                 repo._addToCache(r);
             }
         }
-        let result = await promiseAll(rawRows, async (r) => await this._mapRawDataToResult(r, loadFields));
+        const excludeRelationMembers = new Set(this.fields
+            .toArray()
+            .map((f) => {
+            const i = this.__getRelationAndInclude(f, loadOptions);
+            if (i.rel && !i.incl)
+                return f.key;
+            return undefined;
+        })
+            .filter((x) => x !== undefined));
+        let result = await promiseAll(rawRows, async (r) => await this._mapRawDataToResult(r, loadFields, excludeRelationMembers));
         const fields = this.metadata.fields.toArray();
         this._populateRelationsForFields(fields, loadOptions, result, loader);
         return result;
     }
     _populateRelationsForFields(fields, loadOptions, result, loader) {
         for (const col of fields) {
-            let rel = getRelationFieldInfo(col);
-            let incl = col.options
-                .defaultIncluded;
-            const include = loadOptions?.include?.[col.key];
-            if (include !== undefined) {
-                incl = include;
-            }
-            if (rel && incl) {
-                const otherRepo = rel.toRepo;
-                for (const row of result) {
-                    let { findOptions, returnNull } = this._findOptionsBasedOnRelation(rel, col, incl, row, otherRepo);
-                    const colKey = col.key;
-                    if (returnNull)
-                        row[colKey] = null;
-                    else {
-                        const entityType = rel.toEntity;
-                        const toRepo = otherRepo;
-                        loader
-                            .load({
-                            entityType,
-                            find: (options) => toRepo._rawFind(options, false, loader, (o) => toRepo._edp.find(o)),
-                            metadata: toRepo.metadata,
-                        }, findOptions)
-                            .then((result) => {
-                            if (result.length == 0 && rel.type == 'toOne')
-                                return;
-                            row[colKey] =
-                                rel.type !== 'toMany'
-                                    ? result.length == 0
-                                        ? null
-                                        : result[0]
-                                    : result;
-                        });
+            let { rel, incl } = this.__getRelationAndInclude(col, loadOptions);
+            if (rel)
+                if (incl) {
+                    const otherRepo = rel.toRepo;
+                    for (const row of result) {
+                        let { findOptions, returnNull } = this._findOptionsBasedOnRelation(rel, col, incl, row, otherRepo);
+                        const colKey = col.key;
+                        if (returnNull)
+                            row[colKey] = null;
+                        else {
+                            const entityType = rel.toEntity;
+                            const toRepo = otherRepo;
+                            loader
+                                .load({
+                                entityType,
+                                find: (options) => toRepo._rawFind(options, false, loader, (o) => toRepo._edp.find(o)),
+                                metadata: toRepo.metadata,
+                            }, findOptions)
+                                .then((result) => {
+                                if (result.length == 0 && rel.type == 'toOne')
+                                    return;
+                                row[colKey] =
+                                    rel.type !== 'toMany'
+                                        ? result.length == 0
+                                            ? null
+                                            : result[0]
+                                        : result;
+                            });
+                        }
                     }
                 }
-            }
+                else {
+                    for (const row of result) {
+                        Reflect.deleteProperty(row, col.key);
+                    }
+                }
+        }
+    }
+    __getRelationAndInclude(col, loadOptions) {
+        let rel = getRelationFieldInfo(col);
+        let incl = col.options
+            .defaultIncluded;
+        const include = loadOptions?.include?.[col.key];
+        if (include !== undefined) {
+            incl = include;
         }
+        return { rel, incl };
     }
     /*@internal */
     _findOptionsBasedOnRelation(rel, field, moreFindOptions, row, otherRepo) {
@@ -750,9 +769,9 @@ export class RepositoryImplementation {
             findOptions.limit = 1;
         return { findOptions, returnNull, returnUndefined };
     }
-    async _mapRawDataToResult(r, loadFields) {
+    async _mapRawDataToResult(r, loadFields, excludeRelationMembers) {
         let x = new this._entity(this._remult);
-        let helper = new rowHelperImplementation(this._info, x, this, this._edp, this._remult, false);
+        let helper = new rowHelperImplementation(this._info, x, this, this._edp, this._remult, false, excludeRelationMembers);
         Object.defineProperty(x, entityMember, {
             //I've used define property to hide this member from console.lo g
             get: () => helper,
@@ -1021,7 +1040,7 @@ class rowHelperBase {
         this._error = val;
         this._subscribers?.reportChanged();
     }
-    constructor(fieldsMetadata, instance, remult, isNewRow) {
+    constructor(fieldsMetadata, instance, remult, isNewRow, excludeRelationMembers) {
         this.fieldsMetadata = fieldsMetadata;
         this.instance = instance;
         this.remult = remult;
@@ -1064,7 +1083,7 @@ class rowHelperBase {
                         }
                         refImpl._subscribers.reportChanged();
                     },
-                    enumerable: true,
+                    enumerable: !excludeRelationMembers?.has(col.key),
                 });
                 lookup.set(val);
             }
@@ -1098,7 +1117,7 @@ class rowHelperBase {
                                 }
                             }
                         },
-                        enumerable: true,
+                        enumerable: !excludeRelationMembers?.has(col.key),
                     });
                     if (hasVal)
                         instance[col.key] = val;
@@ -1333,8 +1352,8 @@ export class rowHelperImplementation extends rowHelperBase {
     repo;
     edp;
     _isNew;
-    constructor(info, instance, repo, edp, remult, _isNew) {
-        super(info.fieldsMetadata, instance, remult, _isNew);
+    constructor(info, instance, repo, edp, remult, _isNew, excludeRelationMembers) {
+        super(info.fieldsMetadata, instance, remult, _isNew, excludeRelationMembers);
         this.info = info;
         this.repo = repo;
         this.edp = edp;
@@ -1616,7 +1635,10 @@ export class rowHelperImplementation extends rowHelperBase {
                 }
             }
             else if (!getRelationFieldInfo(col))
-                this.instance[col.key] = data[col.key];
+                if (data[col.key] === undefined)
+                    delete this.instance[col.key];
+                else
+                    this.instance[col.key] = data[col.key];
         }
         await this.calcServerExpression();
         this.id = this.getId();
@@ -1627,12 +1649,13 @@ export class rowHelperImplementation extends rowHelperBase {
         return this.originalId;
     }
     async calcServerExpression() {
-        if (isBackend())
+        if (!this.repo._dataProvider.isProxy)
             //y2 should be changed to be based on data provider - consider naming
             for (const col of this.info.fieldsMetadata) {
                 if (col.options.serverExpression) {
-                    this.instance[col.key] =
-                        (await col.options.serverExpression(this.instance));
+                    const result = (await col.options.serverExpression(this.instance));
+                    if (result !== undefined)
+                        this.instance[col.key] = result;
                 }
             }
     }
@@ -1924,6 +1947,9 @@ export class FieldRefImplementation {
 let tempCaptionTransformer = {
     transformCaption: (remult, key, caption, entityMetaData) => caption,
 };
+export const fieldOptionsEnricher = remultStatic.fieldOptionsEnricher || {
+    enrichFieldOptions: (options) => options,
+};
 export const CaptionTransformer = remultStatic.captionTransformer ||
     (remultStatic.captionTransformer = tempCaptionTransformer);
 export function buildCaption(caption, key, remult, metaData) {
@@ -2335,6 +2361,7 @@ export function buildOptions(options, remult) {
             }
         }
     }
+    fieldOptionsEnricher.enrichFieldOptions?.(r);
     return r;
 }
 export function decorateColumnSettings(settings, remult) {

package/index.d.ts

@@ -2,7 +2,7 @@ import type { ClassType } from './classType.js';
 import type { DataProvider } from './src/data-interfaces.js';
 export { ArrayEntityDataProvider } from './src/data-providers/array-entity-data-provider.js';
 export type { ClassType } from './classType.js';
-export { ValidateFieldEvent, MembersOnly, NumericKeys, FieldsMetadata, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, FindOptionsBase, QueryResult, QueryOptions, Repository, GroupByOptions, GroupByResult, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, EntityRef, SortSegments, Paginator, LiveQuery, LiveQueryChangeInfo, Subscribable, RefSubscriber, RefSubscriberBase, RelationOptions, ObjectMembersOnly, MembersToInclude, RepositoryRelations, EntityIdFields, ClassFieldDecorator, ClassFieldDecoratorContextStub, //n1 consider removing in ts5
+export { ValidateFieldEvent, MembersOnly, NumericKeys, FieldsMetadata, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, FindOptionsBase, QueryResult, QueryOptions, UpsertOptions, Repository, GroupByOptions, GroupByResult, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, EntityRef, SortSegments, Paginator, LiveQuery, LiveQueryChangeInfo, Subscribable, RefSubscriber, RefSubscriberBase, RelationOptions, ObjectMembersOnly, MembersToInclude, RepositoryRelations, EntityIdFields, ClassFieldDecorator, ClassFieldDecoratorContextStub, //n1 consider removing in ts5
 LifecycleEvent, FieldsRefBase, FieldsRefForEntityBase, RepositoryRelationsForEntityBase, ControllerRefForControllerBase, ControllerRefBase, ControllerRef, EntityRefForEntityBase, IdMetadata, FindFirstOptionsBase, } from './src/remult3/remult3.js';
 export { EntityBase, ControllerBase, FieldType, getFields, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, CaptionTransformer, } from './src/remult3/RepositoryImplementation.js';
 export { Entity } from './src/remult3/entity.js';

package/internals.d.ts

@@ -1,5 +1,6 @@
+export { sqlRelations, sqlRelationsFilter, SqlRelations, SqlRelationFilter, } from './src/data-providers/sql-relations.js';
 export { getRelationInfo, getRelationFieldInfo, type RelationFieldInfo, type RelationInfo, type RelationFields, } from './src/remult3/relationInfoMember.js';
-export { decorateColumnSettings, controllerRefImpl, getControllerRef, } from './src/remult3/RepositoryImplementation.js';
+export { decorateColumnSettings, controllerRefImpl, getControllerRef, fieldOptionsEnricher, } from './src/remult3/RepositoryImplementation.js';
 export { getEntitySettings } from './src/remult3/getEntityRef.js';
 export { __updateEntityBasedOnWhere } from './src/filter/filter-interfaces.js';
 export declare const actionInfo: {

package/internals.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.flags = exports.actionInfo = exports.__updateEntityBasedOnWhere = exports.getEntitySettings = exports.getControllerRef = exports.controllerRefImpl = exports.decorateColumnSettings = exports.getRelationFieldInfo = exports.getRelationInfo = void 0;
+exports.flags = exports.actionInfo = exports.__updateEntityBasedOnWhere = exports.getEntitySettings = exports.fieldOptionsEnricher = exports.getControllerRef = exports.controllerRefImpl = exports.decorateColumnSettings = exports.getRelationFieldInfo = exports.getRelationInfo = exports.SqlRelationFilter = exports.sqlRelationsFilter = exports.sqlRelations = void 0;
 var remult_static_js_1 = require("./src/remult-static.js");
+var sql_relations_js_1 = require("./src/data-providers/sql-relations.js");
+Object.defineProperty(exports, "sqlRelations", { enumerable: true, get: function () { return sql_relations_js_1.sqlRelations; } });
+Object.defineProperty(exports, "sqlRelationsFilter", { enumerable: true, get: function () { return sql_relations_js_1.sqlRelationsFilter; } });
+Object.defineProperty(exports, "SqlRelationFilter", { enumerable: true, get: function () { return sql_relations_js_1.SqlRelationFilter; } });
 var relationInfoMember_js_1 = require("./src/remult3/relationInfoMember.js");
 Object.defineProperty(exports, "getRelationInfo", { enumerable: true, get: function () { return relationInfoMember_js_1.getRelationInfo; } });
 Object.defineProperty(exports, "getRelationFieldInfo", { enumerable: true, get: function () { return relationInfoMember_js_1.getRelationFieldInfo; } });
@@ -9,6 +13,7 @@ var RepositoryImplementation_js_1 = require("./src/remult3/RepositoryImplementat
 Object.defineProperty(exports, "decorateColumnSettings", { enumerable: true, get: function () { return RepositoryImplementation_js_1.decorateColumnSettings; } });
 Object.defineProperty(exports, "controllerRefImpl", { enumerable: true, get: function () { return RepositoryImplementation_js_1.controllerRefImpl; } });
 Object.defineProperty(exports, "getControllerRef", { enumerable: true, get: function () { return RepositoryImplementation_js_1.getControllerRef; } });
+Object.defineProperty(exports, "fieldOptionsEnricher", { enumerable: true, get: function () { return RepositoryImplementation_js_1.fieldOptionsEnricher; } });
 var getEntityRef_js_1 = require("./src/remult3/getEntityRef.js");
 Object.defineProperty(exports, "getEntitySettings", { enumerable: true, get: function () { return getEntityRef_js_1.getEntitySettings; } });
 var filter_interfaces_js_1 = require("./src/filter/filter-interfaces.js");

package/package.json

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

package/remult-sqlite3.js

@@ -7,14 +7,14 @@ var index_js_1 = require("./index.js");
 var remult_sqlite_core_js_1 = require("./remult-sqlite-core.js");
 function createSqlite3DataProvider() {
     return tslib_1.__awaiter(this, arguments, void 0, function (fileName) {
-        var Database;
+        var sqlite3;
         if (fileName === void 0) { fileName = ':memory:'; }
         return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0: return [4 /*yield*/, Promise.resolve().then(function () { return tslib_1.__importStar(require('sqlite3')); })];
                 case 1:
-                    Database = (_a.sent()).Database;
-                    return [2 /*return*/, new index_js_1.SqlDatabase(new Sqlite3DataProvider(new Database(fileName)))];
+                    sqlite3 = _a.sent();
+                    return [2 /*return*/, new index_js_1.SqlDatabase(new Sqlite3DataProvider(new sqlite3.default.Database(fileName)))];
             }
         });
     });