remult 0.27.21-next.8 → 0.27.21

package/server/test-api-data-provider.d.ts

@@ -1,5 +1,3 @@
 import { RestDataProvider } from '../index.js';
 import type { RemultServerOptions } from './index.js';
-export declare function TestApiDataProvider(options?: Pick<RemultServerOptions<unknown>, 'ensureSchema' | 'dataProvider'> & {
-    sqlite3?: boolean;
-}): RestDataProvider;
+export declare function TestApiDataProvider(options?: Pick<RemultServerOptions<unknown>, 'ensureSchema' | 'dataProvider'>): RestDataProvider;

package/server/test-api-data-provider.js

@@ -12,27 +12,8 @@ function TestApiDataProvider(options) {
     if (!options)
         options = {};
     var dp = (0, initDataProvider_js_1.initDataProvider)(options.dataProvider, false, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-        var sqlite3, Sqlite3DataProvider, error_1;
         return tslib_1.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!!(options === null || options === void 0 ? void 0 : options.sqlite3)) return [3 /*break*/, 1];
-                    return [2 /*return*/, new index_js_1.InMemoryDataProvider()];
-                case 1:
-                    _a.trys.push([1, 4, , 5]);
-                    return [4 /*yield*/, Promise.resolve().then(function () { return tslib_1.__importStar(require('sqlite3')); })];
-                case 2:
-                    sqlite3 = _a.sent();
-                    return [4 /*yield*/, Promise.resolve().then(function () { return tslib_1.__importStar(require('../remult-sqlite3.js')); })];
-                case 3:
-                    Sqlite3DataProvider = (_a.sent()).Sqlite3DataProvider;
-                    return [2 /*return*/, new index_js_1.SqlDatabase(new Sqlite3DataProvider(new sqlite3.default.Database(':memory:')))];
-                case 4:
-                    error_1 = _a.sent();
-                    console.error("Failed to initialize sqlite3, make sure you run:\nnpm i -D sqlite3\n", error_1);
-                    throw error_1;
-                case 5: return [2 /*return*/];
-            }
+            return [2 /*return*/, new index_js_1.InMemoryDataProvider()];
         });
     }); });
     var server = (0, remult_api_server_js_1.createRemultServerCore)(tslib_1.__assign(tslib_1.__assign({}, options), { dataProvider: dp }), {

package/src/data-providers/sql-relations.d.ts

@@ -0,0 +1,40 @@
+import type { ClassType } from '../../classType.js';
+import { type EntityDbNames } from '../filter/filter-consumer-bridge-to-sql-request.js';
+import type { EntityFilter, EntityOrderBy, ObjectMembersOnly } from '../remult3/remult3.js';
+import type { SqlCommandWithParameters } from '../sql-command.js';
+export declare function sqlRelations<entityType>(forEntity: ClassType<entityType>): SqlRelations<entityType>;
+export type SqlRelations<entityType> = {
+    [p in keyof ObjectMembersOnly<entityType>]-?: SqlRelation<ArrayItemType<NonNullable<entityType[p]>>>;
+};
+export type SubQueryWhat<toEntity> = (fieldNamesOfToEntity: EntityDbNames<toEntity>) => string | Promise<string>;
+export type SubQueryOptions<toEntity> = {
+    where?: EntityFilter<toEntity>;
+    orderBy?: EntityOrderBy<toEntity>;
+    first?: boolean;
+    c?: SqlCommandWithParameters;
+};
+export type SqlFirst<toEntity> = {
+    $subQuery(what: SubQueryWhat<toEntity>): Promise<string>;
+    $relations: {
+        [P in keyof ObjectMembersOnly<toEntity>]-?: SqlRelation<toEntity[P]>;
+    };
+} & {
+    [P in keyof toEntity]-?: Promise<string>;
+};
+export type SqlRelation<toEntity> = {
+    $count(where?: EntityFilter<toEntity>): Promise<string>;
+    $subQuery(what: SubQueryWhat<toEntity>, options?: SubQueryOptions<toEntity>): Promise<string>;
+    $relations: {
+        [P in keyof ObjectMembersOnly<toEntity>]-?: SqlRelation<toEntity[P]>;
+    };
+    $first(options?: Pick<SubQueryOptions<toEntity>, 'where' | 'orderBy'>): SqlFirst<toEntity>;
+} & {
+    [P in keyof toEntity]-?: Promise<string>;
+};
+export type ArrayItemType<T> = T extends (infer U)[] ? U : T;
+export declare function sqlRelationsFilter<entityType>(forEntity: ClassType<entityType>): { [p in keyof entityType]-?: SqlRelationFilter<entityType, p, ArrayItemType<NonNullable<entityType[p]>>>; };
+export declare class SqlRelationFilter<myEntity, relationKey extends keyof myEntity, toEntity = ArrayItemType<myEntity[relationKey]>> {
+    private _tools;
+    constructor(myEntity: ClassType<myEntity>, relationField: relationKey);
+    some(where?: EntityFilter<toEntity>): EntityFilter<toEntity>;
+}

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

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlRelationFilter = void 0;
+exports.sqlRelations = sqlRelations;
+exports.sqlRelationsFilter = sqlRelationsFilter;
+var tslib_1 = require("tslib");
+var filter_consumer_bridge_to_sql_request_js_1 = require("../filter/filter-consumer-bridge-to-sql-request.js");
+var relationInfoMember_js_1 = require("../remult3/relationInfoMember.js");
+var sql_database_js_1 = require("./sql-database.js");
+var remult_proxy_js_1 = require("../remult-proxy.js");
+function sqlRelations(forEntity) {
+    return new Proxy({}, {
+        get: function (target, relationField) {
+            return new Proxy(new SqlRelationTools(forEntity, relationField), {
+                get: function (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];
+                },
+            });
+        },
+    });
+}
+var SqlRelationTools = /** @class */ (function () {
+    function SqlRelationTools(myEntity, relationField) {
+        var _this = this;
+        this.myEntity = myEntity;
+        this.relationField = relationField;
+        this.$count = function (where) {
+            return _this.$subQuery(function () { return 'count(*)'; }, { where: where });
+        };
+        this.$first = function (options) {
+            return new Proxy(_this, {
+                get: function (target, prop) {
+                    if (prop == '$subQuery')
+                        return function (what) {
+                            return target.$subQuery(what, tslib_1.__assign(tslib_1.__assign({}, options), { first: true }));
+                        };
+                    if (prop == '$relations')
+                        return _this.___relations(tslib_1.__assign(tslib_1.__assign({}, options), { first: true }));
+                    return target.$subQuery(function (fieldNamesOfToEntity) {
+                        return fieldNamesOfToEntity.$dbNameOf(prop);
+                    }, tslib_1.__assign(tslib_1.__assign({}, options), { first: true }));
+                },
+            });
+        };
+        this.$fields = new Proxy(this, {
+            get: function (target, field) {
+                return target.$subQuery(function (fieldNamesOfToEntity) {
+                    return fieldNamesOfToEntity.$dbNameOf(field);
+                });
+            },
+        });
+        this.$subQuery = function (what, options) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var rel, relFields, filters, namesOfOtherTable, namesOfMyTable, key, otherTableFilter, result, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        rel = (0, relationInfoMember_js_1.getRelationFieldInfo)(remult_proxy_js_1.remult.repo(this.myEntity).fields.find(this.relationField));
+                        if (!rel)
+                            throw new Error("".concat(this.relationField, " is not a relation"));
+                        relFields = rel.getFields();
+                        filters = [];
+                        return [4 /*yield*/, (0, filter_consumer_bridge_to_sql_request_js_1.dbNamesOf)(rel.toEntity, {
+                                tableName: true,
+                            })];
+                    case 1:
+                        namesOfOtherTable = _b.sent();
+                        return [4 /*yield*/, (0, filter_consumer_bridge_to_sql_request_js_1.dbNamesOf)(this.myEntity, { tableName: true })];
+                    case 2:
+                        namesOfMyTable = _b.sent();
+                        for (key in relFields.fields) {
+                            if (Object.prototype.hasOwnProperty.call(relFields.fields, key)) {
+                                filters.push("".concat(namesOfOtherTable.$dbNameOf(key), " = ").concat(namesOfMyTable.$dbNameOf(relFields.fields[key])));
+                            }
+                        }
+                        return [4 /*yield*/, sql_database_js_1.SqlDatabase.filterToRaw(remult_proxy_js_1.remult.repo(rel.toEntity), 
+                            // eslint-disable-next-line
+                            options === null || options === void 0 ? void 0 : options.where, undefined, namesOfOtherTable)];
+                    case 3:
+                        otherTableFilter = _b.sent();
+                        if (otherTableFilter)
+                            filters.push(otherTableFilter);
+                        _a = "\n( SELECT ".concat;
+                        return [4 /*yield*/, what(namesOfOtherTable)];
+                    case 4:
+                        result = _a.apply("\n( SELECT ", [_b.sent(), " \n  FROM "]).concat(namesOfOtherTable, " \n  WHERE ").concat(filters.join(' and '));
+                        if (options === null || options === void 0 ? void 0 : options.orderBy) {
+                            result += "\n  ORDER BY ".concat(Object.keys(options.orderBy)
+                                .map(function (key) {
+                                return "".concat(namesOfOtherTable.$dbNameOf(key), " ").concat(options.orderBy[key]);
+                            })
+                                .join(', '));
+                        }
+                        if (options === null || options === void 0 ? void 0 : options.first) {
+                            result += "\n  LIMIT 1";
+                        }
+                        return [2 /*return*/, (result +
+                                "\n)")];
+                }
+            });
+        }); };
+    }
+    SqlRelationTools.prototype.___relations = function (options) {
+        var _this = this;
+        return new Proxy(this, {
+            get: function (target, field) {
+                var rel1 = (0, relationInfoMember_js_1.getRelationFieldInfo)(remult_proxy_js_1.remult.repo(_this.myEntity).fields.find(_this.relationField));
+                return new Proxy(_this, {
+                    get: function (target, field1) {
+                        return _this.$subQuery(function () {
+                            return indent(sqlRelations(rel1.toEntity)[field][field1]);
+                        }, options);
+                    },
+                });
+            },
+        });
+    };
+    return SqlRelationTools;
+}());
+function sqlRelationsFilter(forEntity) {
+    return new Proxy({}, {
+        get: function (target, relationField) {
+            return new SqlRelationFilter(forEntity, relationField);
+        },
+    });
+}
+var SqlRelationFilter = /** @class */ (function () {
+    function SqlRelationFilter(myEntity, relationField) {
+        this._tools = new SqlRelationTools(myEntity, relationField);
+    }
+    SqlRelationFilter.prototype.some = function (where) {
+        var _this = this;
+        //many orms use some, every, none
+        return sql_database_js_1.SqlDatabase.rawFilter(function (c) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = 'exists ';
+                        return [4 /*yield*/, this._tools.$subQuery(function () { return '1'; }, {
+                                where: where,
+                                c: c,
+                            })];
+                    case 1: return [2 /*return*/, (_a +
+                            (_b.sent()))];
+                }
+            });
+        }); });
+    };
+    return SqlRelationFilter;
+}());
+exports.SqlRelationFilter = SqlRelationFilter;
+function indent(s) {
+    return s.then(function (s) {
+        return s
+            .split('\n')
+            .map(function (x) { return '  ' + x; })
+            .join('\n');
+    });
+}

package/src/remult-static.d.ts

@@ -19,6 +19,7 @@ export declare const remultStatic: {
             close: () => void;
         };
     };
+    fieldOptionsEnricher: any;
     captionTransformer: any;
     defaultDataProvider: () => Promise<DataProvider | undefined>;
 };

package/src/remult-static.js

@@ -23,6 +23,7 @@ var x = {
             close: function () { },
         }); },
     },
+    fieldOptionsEnricher: undefined,
     captionTransformer: undefined,
     defaultDataProvider: function () {
         return undefined;

package/src/remult3/RepositoryImplementation.d.ts

@@ -73,6 +73,7 @@ export declare class RepositoryImplementation<entityType> implements Repository<
     _fromJsonArray(jsonItems: any[], loadOptions: LoadOptions<entityType>): Promise<entityType[]>;
     private _loadManyToOneForManyRows;
     private _populateRelationsForFields;
+    private __getRelationAndInclude;
     private _mapRawDataToResult;
     toJson(item: entityType | entityType[] | Promise<entityType> | Promise<entityType[]>): any;
     fromJson(x: any[], isNew?: boolean): entityType[];
@@ -100,7 +101,7 @@ declare abstract class rowHelperBase<T> {
     _error?: string;
     get error(): string | undefined;
     set error(val: string | undefined);
-    constructor(fieldsMetadata: FieldMetadata[], instance: T, remult: Remult, isNewRow: boolean);
+    constructor(fieldsMetadata: FieldMetadata[], instance: T, remult: Remult, isNewRow: boolean, excludeRelationMembers?: Set<string>);
     _subscribers?: SubscribableImp;
     subscribe(listener: RefSubscriber): Unsubscribe;
     _isLoading: boolean;
@@ -134,7 +135,7 @@ export declare class rowHelperImplementation<T> extends rowHelperBase<T> impleme
     private repo;
     private edp;
     private _isNew;
-    constructor(info: EntityFullInfo<T>, instance: T, repo: RepositoryImplementation<T>, edp: EntityDataProvider, remult: Remult, _isNew: boolean);
+    constructor(info: EntityFullInfo<T>, instance: T, repo: RepositoryImplementation<T>, edp: EntityDataProvider, remult: Remult, _isNew: boolean, excludeRelationMembers?: Set<string>);
     repository: Repository<unknown>;
     clone(): T;
     get relations(): RepositoryRelations<T>;
@@ -206,6 +207,9 @@ export declare class FieldRefImplementation<entityType, valueType> implements Fi
     __performValidation(): Promise<void>;
     validate(): Promise<boolean>;
 }
+export declare const fieldOptionsEnricher: {
+    enrichFieldOptions: (options: FieldOptions) => void;
+};
 export declare const CaptionTransformer: {
     /**
      * Transforms the caption of a column based on custom rules or criteria.