remult 0.27.20-next.4 → 0.27.20

package/esm/graphql.js

@@ -315,7 +315,7 @@ export function remultGraphql(options) {
                     value: getMetaType(meta),
                 }, argErrorDetail, argClientMutationId);
                 root[createResolverKey] = handleMutationWithErrors(async (dApi, response, setResult, arg1, req) => {
-                    await dApi.httpPost({
+                    await dApi.post({
                         ...response,
                         created: (y) => {
                             const orig = { ...y };
@@ -324,7 +324,7 @@ export function remultGraphql(options) {
                                 [toCamelCase(getMetaType(meta))]: y,
                             });
                         },
-                    }, { get: () => undefined }, arg1.input, undefined);
+                    }, arg1.input);
                 });
                 resolversMutation[createResolverKey] = (origItem, args, req, gqlInfo) => root[createResolverKey](args, req, gqlInfo);
             }

package/esm/remult-mongo.js

@@ -266,9 +266,7 @@ class MongoEntityDataProvider {
         const { e, collection } = await this.collection();
         let f = new FilterConsumerBridgeToMongo(e);
         Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
-        await collection.deleteOne(await f.resolveWhere(), {
-            session: this.session,
-        });
+        collection.deleteOne(await f.resolveWhere(), { session: this.session });
     }
     async insert(data) {
         let { collection, e } = await this.collection();

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

@@ -258,7 +258,7 @@ export class RemultServerImplementation {
         if (this.options.logApiEndPoints)
             console.info('[remult] ' + myRoute);
         r.route(myRoute)
-            .get(this.process(async (c, req, res, orig) => dataApiFactory(c).httpGet(res, req, () => this.serializeContext(c))))
+            .get(this.process((c, req, res, orig) => dataApiFactory(c).httpGet(res, req, () => this.serializeContext(c))))
             .put(this.process(async (c, req, res, _, __, orig) => dataApiFactory(c).updateManyThroughPutRequest(res, req, await this.coreOptions.getRequestBody(orig))))
             .delete(this.process(async (c, req, res, _, __, orig) => dataApiFactory(c).deleteMany(res, req, undefined)))
             .post(this.process(async (c, req, res, _, __, orig) => dataApiFactory(c).httpPost(res, req, await this.coreOptions.getRequestBody(orig), () => this.serializeContext(c))));

package/esm/src/data-api.js

@@ -20,7 +20,7 @@ export class DataApi {
             case 'count':
                 return this.count(res, req, undefined);
             case 'groupBy':
-                return res.success(this.groupBy(req, undefined));
+                return this.groupBy(res, req, undefined);
         }
         return this.getArray(res, req, undefined);
     }
@@ -34,90 +34,31 @@ export class DataApi {
                 };
             }
         }
-        try {
-            if (action?.startsWith(liveQueryAction)) {
-                validateWhereInBody();
-                return this.liveQuery(res, req, body, serializeContext, action.substring(liveQueryAction.length));
-            }
-            switch (action) {
-                case 'get':
-                    validateWhereInBody();
-                    return this.getArray(res, req, body);
-                case 'count':
-                    validateWhereInBody();
-                    return this.count(res, req, body);
-                case 'groupBy':
-                    return res.success(await this.groupBy(req, body));
-                case 'deleteMany':
-                    validateWhereInBody();
-                    return this.deleteMany(res, req, body);
-                case 'updateMany':
-                    validateWhereInBody();
-                    return this.updateManyImplementation(res, req, body);
-                case 'upsertMany':
-                    return this.upsertMany(res, req, body);
-                case 'endLiveQuery':
-                    await this.remult.liveQueryStorage.remove(body.id);
-                    res.success('ok');
-                    return;
-                case 'query':
-                    return res.success(await this.query(res, req, body));
-                default:
-                    return res.created(await this.post(body));
-            }
-        }
-        catch (err) {
-            if (err.isForbiddenError)
-                res.forbidden(err.message);
-            else
-                res.error(err, this.repository.metadata);
+        if (action?.startsWith(liveQueryAction)) {
+            validateWhereInBody();
+            return this.liveQuery(res, req, body, serializeContext, action.substring(liveQueryAction.length));
         }
-    }
-    async upsertMany(response, request, body) {
-        return await doTransaction(this.remult, async () => {
-            let result = [];
-            for (const item of body) {
-                let where = await this.buildWhere(request, { where: item.where });
-                Filter.throwErrorIfFilterIsEmpty(where, 'upsert');
-                let r = await this.repository.find({
-                    where,
-                    include: this.includeNone(),
-                });
-                if (r.length == 0) {
-                    result.push(await this.post({ ...item.where, ...item.set }));
-                }
-                else {
-                    if (item.set !== undefined) {
-                        result.push((await this.actualUpdate(r[0], item.set)).toApiJson());
-                    }
-                    else
-                        result.push(this.repository.getEntityRef(r[0]).toApiJson());
-                }
-            }
-            response.success(result);
-        });
-    }
-    async query(response, request, body) {
-        if (!this.repository.metadata.apiReadAllowed) {
-            response.forbidden();
-            return;
-        }
-        try {
-            let { aggregate, ...rest } = body;
-            let [{ r }, [aggregates]] = await Promise.all([
-                this.getArrayImpl(request, rest),
-                this.groupBy(request, aggregate),
-            ]);
-            return {
-                items: r,
-                aggregates,
-            };
-        }
-        catch (err) {
-            if (err.isForbiddenError)
-                response.forbidden();
-            else
-                response.error(err, this.repository.metadata);
+        switch (action) {
+            case 'get':
+                validateWhereInBody();
+                return this.getArray(res, req, body);
+            case 'count':
+                validateWhereInBody();
+                return this.count(res, req, body);
+            case 'groupBy':
+                return this.groupBy(res, req, body);
+            case 'deleteMany':
+                validateWhereInBody();
+                return this.deleteMany(res, req, body);
+            case 'updateMany':
+                validateWhereInBody();
+                return this.updateManyImplementation(res, req, body);
+            case 'endLiveQuery':
+                await this.remult.liveQueryStorage.remove(body.id);
+                res.success('ok');
+                return;
+            default:
+                return this.post(res, body);
         }
     }
     static defaultGetLimit = 0;
@@ -151,7 +92,6 @@ export class DataApi {
                 for await (const x of this.repository.query({
                     where,
                     include: this.includeNone(),
-                    aggregate: undefined,
                 })) {
                     await this.actualDelete(x);
                     deleted++;
@@ -163,7 +103,7 @@ export class DataApi {
             response.error(err, this.repository.metadata);
         }
     }
-    async groupBy(request, body) {
+    async groupBy(response, request, body) {
         let findOptions = await this.findOptionsFromRequest(request, body);
         let orderBy = {};
         if (body?.orderBy) {
@@ -206,9 +146,9 @@ export class DataApi {
                     x[f] = this.repository.fields.find(f).valueConverter.toJson(x[f]);
                 }
             });
-        return result;
+        response.success(result);
     }
-    async getArrayImpl(request, body) {
+    async getArrayImpl(response, request, body) {
         let findOptions = await this.findOptionsFromRequest(request, body);
         const r = await this.repository.find(findOptions).then(async (r) => {
             return await Promise.all(r.map(async (y) => this.repository.getEntityRef(y).toApiJson()));
@@ -284,7 +224,7 @@ export class DataApi {
             return;
         }
         try {
-            const { r } = await this.getArrayImpl(request, body);
+            const { r } = await this.getArrayImpl(response, request, body);
             response.success(r);
         }
         catch (err) {
@@ -300,7 +240,7 @@ export class DataApi {
             return;
         }
         try {
-            const r = await this.getArrayImpl(request, body);
+            const r = await this.getArrayImpl(response, request, body);
             const data = {
                 requestJson: await serializeContext(),
                 findOptionsJson: findOptionsToJson(r.findOptions, this.repository.metadata),
@@ -405,7 +345,6 @@ export class DataApi {
                 for await (const x of this.repository.query({
                     where,
                     include: this.includeNone(),
-                    aggregate: undefined,
                 })) {
                     await this.actualUpdate(x, body.set);
                     updated++;
@@ -444,27 +383,35 @@ export class DataApi {
             response.deleted();
         });
     }
-    async post(body) {
-        const insert = async (what) => {
-            let newr = this.repository.create();
-            await this.repository.getEntityRef(newr)._updateEntityBasedOnApi(what);
-            if (!this.repository.getEntityRef(newr).apiInsertAllowed) {
-                throw new ForbiddenError();
-            }
-            await this.repository.getEntityRef(newr).save();
-            return this.repository.getEntityRef(newr).toApiJson();
-        };
-        if (Array.isArray(body)) {
-            const result = [];
-            await doTransaction(this.remult, async () => {
-                for (const item of body) {
-                    result.push(await insert(item));
+    async post(response, body) {
+        try {
+            const insert = async (what) => {
+                let newr = this.repository.create();
+                await this.repository.getEntityRef(newr)._updateEntityBasedOnApi(what);
+                if (!this.repository.getEntityRef(newr).apiInsertAllowed) {
+                    throw new ForbiddenError();
                 }
-            });
-            return result;
+                await this.repository.getEntityRef(newr).save();
+                return this.repository.getEntityRef(newr).toApiJson();
+            };
+            if (Array.isArray(body)) {
+                const result = [];
+                await doTransaction(this.remult, async () => {
+                    for (const item of body) {
+                        result.push(await insert(item));
+                    }
+                });
+                response.created(result);
+            }
+            else
+                response.created(await insert(body));
+        }
+        catch (err) {
+            if (err.isForbiddenError)
+                response.forbidden(err.message);
+            else
+                response.error(err, this.repository.metadata);
         }
-        else
-            return await insert(body);
     }
 }
 export function determineSort(sortUrlParm, dirUrlParam) {

package/esm/src/data-providers/rest-data-provider.js

@@ -103,35 +103,13 @@ export class RestEntityDataProvider {
         this.http = http;
         this.entity = entity;
     }
-    query(options, aggregateOptions) {
-        const r = this.buildFindRequest(options);
-        return r
-            .run('query', {
-            aggregate: this.buildAggregateOptions(aggregateOptions),
-        })
-            .then(({ items, aggregates }) => ({
-            items: items.map((x) => this.translateFromJson(x)),
-            aggregates,
-        }));
-    }
     async groupBy(options) {
         const { run } = this.buildFindRequest({
             where: options?.where,
             limit: options?.limit,
             page: options?.page,
         });
-        const body = this.buildAggregateOptions(options);
-        const result = await run('groupBy', Object.keys(body).length > 0 ? body : undefined);
-        if (options?.group)
-            result.forEach((row) => {
-                for (const g of options.group) {
-                    row[g.key] = g.valueConverter.fromJson(row[g.key]);
-                }
-            });
-        return result;
-    }
-    buildAggregateOptions(options) {
-        return {
+        const body = {
             groupBy: options?.group?.map((x) => x.key),
             sum: options?.sum?.map((x) => x.key),
             avg: options?.avg?.map((x) => x.key),
@@ -140,6 +118,14 @@ export class RestEntityDataProvider {
             distinctCount: options?.distinctCount?.map((x) => x.key),
             orderBy: options?.orderBy?.map((x) => ({ ...x, field: x.field?.key })),
         };
+        const result = await run('groupBy', Object.keys(body).length > 0 ? body : undefined);
+        if (options?.group)
+            result.forEach((row) => {
+                for (const g of options.group) {
+                    row[g.key] = g.valueConverter.fromJson(row[g.key]);
+                }
+            });
+        return result;
     }
     translateFromJson(row) {
         let result = {};
@@ -167,13 +153,6 @@ export class RestEntityDataProvider {
         const { run } = this.buildFindRequest({ where }, 'put');
         return run('updateMany', this.toJsonOfIncludedKeys(data)).then((r) => +r.updated);
     }
-    async upsertMany(options) {
-        const { run } = this.buildFindRequest(undefined);
-        return run('upsertMany', options.map((x) => ({
-            where: this.toJsonOfIncludedKeys(x.where),
-            set: x.set !== undefined ? this.toJsonOfIncludedKeys(x.set) : undefined,
-        }))).then((r) => r.map((x) => this.translateFromJson(x)));
-    }
     find(options) {
         let { run } = this.buildFindRequest(options);
         return run().then((x) => x.map((y) => this.translateFromJson(y)));

package/esm/src/remult-proxy.js

@@ -161,18 +161,14 @@ export class RemultProxy {
             get metadata() {
                 return remultStatic.remultFactory().repo(...args).metadata;
             },
-            query: (options) => self
+            query: (...args2) => self
                 .remultFactory()
                 .repo(...args)
-                .query(options),
+                .query(...args2),
             save: (args2) => self
                 .remultFactory()
                 .repo(...args)
                 .save(args2),
-            upsert: (args2) => self
-                .remultFactory()
-                .repo(...args)
-                .upsert(args2),
             update: (a, b) => self
                 .remultFactory()
                 .repo(...args)

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, isBackend, queryConfig } from '../context.js';
 import { Filter } from '../filter/filter-interfaces.js';
 import { Sort } from '../sort.js';
 import { GroupByForApiKey, } from './remult3.js';
@@ -18,7 +18,6 @@ import { remultStatic } from '../remult-static.js';
 import { Validators } from '../validators.js';
 import { addValidator } from './addValidator.js';
 import { isOfType } from '../isOfType.js';
-import { QueryResultImpl } from './QueryResultImpl.js';
 //import  { remult } from "../remult-proxy";
 let classValidatorValidate = undefined;
 // import ("class-validator".toString())
@@ -133,23 +132,6 @@ export class RepositoryImplementation {
         return (await this.groupBy(options))[0];
     }
     async groupBy(options) {
-        var dpOptions = await this.__buildGroupByOptions(options);
-        const result = await this._edp.groupBy(dpOptions);
-        //@ts-ignore
-        if (!options?.[GroupByForApiKey] && options.group) {
-            const loaderOptions = {
-                include: {},
-            };
-            for (const key of options.group) {
-                loaderOptions.include[key] = true;
-            }
-            const loader = new RelationLoader();
-            await this._populateRelationsForFields(dpOptions.group, loaderOptions, result, loader);
-            await loader.resolveAll();
-        }
-        return result;
-    }
-    async __buildGroupByOptions(options) {
         let findOptions = await this._buildEntityDataProviderFindOptions({
             ...options,
         });
@@ -203,7 +185,20 @@ export class RepositoryImplementation {
                 }
             }
         }
-        return dpOptions;
+        const result = await this._edp.groupBy(dpOptions);
+        //@ts-ignore
+        if (!options?.[GroupByForApiKey] && options.group) {
+            const loaderOptions = {
+                include: {},
+            };
+            for (const key of options.group) {
+                loaderOptions.include[key] = true;
+            }
+            const loader = new RelationLoader();
+            await this._populateRelationsForFields(dpOptions.group, loaderOptions, result, loader);
+            await loader.resolveAll();
+        }
+        return result;
     }
     _idCache = new Map();
     _getCachedById(id, doNotLoadIfNotFound) {
@@ -350,26 +345,14 @@ export class RepositoryImplementation {
             }
         }
     }
-    __createDto(basedOn) {
-        const ref = this.getEntityRef({
-            ...basedOn,
-        });
-        const r = ref.copyDataToObject(false);
-        const keys = Object.keys(basedOn);
-        for (const element of this.fields) {
-            if (element.dbReadOnly || !keys.includes(element.key))
-                delete r[element.key];
-        }
-        return r;
-    }
     async updateMany({ where, set, }) {
         Filter.throwErrorIfFilterIsEmpty(where, 'updateMany');
         if (this._dataProvider.isProxy) {
-            return this._edp.updateMany(await this._translateWhereToFilter(where), this.__createDto({ ...set }));
+            return this._edp.updateMany(await this._translateWhereToFilter(where), set);
         }
         else {
             let updated = 0;
-            for await (const item of this.query({ where, aggregate: undefined })) {
+            for await (const item of this.query({ where })) {
                 assign(item, set);
                 await getEntityRef(item).save();
                 updated++;
@@ -418,40 +401,6 @@ export class RepositoryImplementation {
             return await ref.save();
         }
     }
-    async upsert(options) {
-        if (this._dataProvider.isProxy) {
-            let rawRows = await this._edp.upsertMany((Array.isArray(options) ? options : [options]).map((x) => ({
-                where: this.__createDto(x.where),
-                set: x.set ? this.__createDto(x.set) : undefined,
-            })));
-            const loader = new RelationLoader();
-            const result = await this._loadManyToOneForManyRows(rawRows, {}, loader);
-            await loader.resolveAll();
-            if (Array.isArray(options))
-                return result;
-            else
-                return result[0];
-        }
-        if (Array.isArray(options)) {
-            return promiseAll(options, (x) => this.upsert(x));
-        }
-        let op = options;
-        var row = await this.findFirst(op.where, { createIfNotFound: true });
-        var ref = getEntityRef(row, false);
-        if (ref.isNew()) {
-            if (op.set) {
-                assign(row, op.set);
-            }
-            return await ref.save();
-        }
-        else {
-            if (op.set) {
-                assign(row, op.set);
-                return await ref.save();
-            }
-            return row;
-        }
-    }
     _getRefForExistingRow(entity, id) {
         let ref = getEntityRef(entity, false);
         if (!ref) {
@@ -516,7 +465,7 @@ export class RepositoryImplementation {
             },
         };
     }
-    async _rawFind(options, skipOrderByAndLimit = false, loader, actualFind) {
+    async _rawFind(options, skipOrderByAndLimit = false, loader) {
         if (!options)
             options = {};
         if (this._defaultFindOptions) {
@@ -528,13 +477,13 @@ export class RepositoryImplementation {
             delete opt.limit;
         }
         Remult.onFind(this._info, options);
-        const rawRows = await actualFind(opt);
+        const rawRows = await this._edp.find(opt);
         let result = await this._loadManyToOneForManyRows(rawRows, options, loader);
         return result;
     }
     async find(options, skipOrderByAndLimit = false) {
         const loader = new RelationLoader();
-        const result = await this._rawFind(options, skipOrderByAndLimit, loader, (x) => this._edp.find(x));
+        const result = await this._rawFind(options, skipOrderByAndLimit, loader);
         await loader.resolveAll();
         return result;
     }
@@ -629,7 +578,7 @@ export class RepositoryImplementation {
                         loader
                             .load({
                             entityType,
-                            find: (options) => toRepo._rawFind(options, false, loader, (o) => toRepo._edp.find(o)),
+                            find: (options) => toRepo._rawFind(options, false, loader),
                             metadata: toRepo.metadata,
                         }, findOptions)
                             .then((result) => {
@@ -780,7 +729,7 @@ export class RepositoryImplementation {
         }
         else {
             let deleted = 0;
-            for await (const item of this.query({ where, aggregate: undefined })) {
+            for await (const item of this.query({ where })) {
                 await getEntityRef(item).delete();
                 deleted++;
             }
@@ -1506,9 +1455,11 @@ export class rowHelperImplementation extends rowHelperBase {
         await this.__validateEntity();
         this.__assertValidity();
         let d = this.copyDataToObject(this.isNew());
+        let ignoreKeys = [];
         for (const field of this.metadata.fields) {
             if (field.dbReadOnly) {
                 d[field.key] = undefined;
+                ignoreKeys.push(field.key);
                 let f = this.fields.find(field);
                 f.value = f.originalValue;
             }
@@ -2429,6 +2380,116 @@ export class ControllerBase {
         return getControllerRef(this, this.remult);
     }
 }
+class QueryResultImpl {
+    options;
+    repo;
+    constructor(options, repo) {
+        this.options = options;
+        this.repo = repo;
+        if (!this.options)
+            this.options = {};
+        if (!this.options.pageSize) {
+            this.options.pageSize = queryConfig.defaultPageSize;
+        }
+    }
+    _count = undefined;
+    async getPage(page) {
+        if ((page ?? 0) < 1)
+            page = 1;
+        return this.repo.find({
+            where: this.options.where,
+            orderBy: this.options.orderBy,
+            limit: this.options.pageSize,
+            page: page,
+            load: this.options.load,
+            include: this.options.include,
+        });
+    }
+    async count() {
+        if (this._count === undefined)
+            this._count = await this.repo.count(this.options.where);
+        return this._count;
+    }
+    async forEach(what) {
+        let i = 0;
+        for await (const x of this) {
+            await what(x);
+            i++;
+        }
+        return i;
+    }
+    async paginator(pNextPageFilter) {
+        this.options.orderBy = Sort.createUniqueEntityOrderBy(this.repo.metadata, this.options.orderBy);
+        let items = await this.repo.find({
+            where: {
+                $and: [this.options.where, pNextPageFilter],
+            },
+            orderBy: this.options.orderBy,
+            limit: this.options.pageSize,
+            load: this.options.load,
+            include: this.options.include,
+        });
+        let nextPage = () => {
+            throw new Error('no more pages');
+        };
+        let hasNextPage = items.length == this.options.pageSize;
+        if (hasNextPage) {
+            let nextPageFilter = await this.repo._createAfterFilter(this.options.orderBy, items[items.length - 1]);
+            nextPage = () => this.paginator(nextPageFilter);
+        }
+        return {
+            count: () => this.count(),
+            hasNextPage,
+            items,
+            nextPage,
+        };
+    }
+    [Symbol.asyncIterator]() {
+        if (!this.options.where) {
+            this.options.where = {};
+        }
+        let ob = this.options.orderBy;
+        this.options.orderBy = Sort.createUniqueEntityOrderBy(this.repo.metadata, ob);
+        let itemIndex = -1;
+        let currentPage = undefined;
+        let itStrategy;
+        let j = 0;
+        itStrategy = async () => {
+            if (this.options.progress) {
+                this.options.progress.progress(j++ / (await this.count()));
+            }
+            if (currentPage === undefined || itemIndex == currentPage.items.length) {
+                if (currentPage && !currentPage.hasNextPage)
+                    return { value: undefined, done: true };
+                let prev = currentPage;
+                if (currentPage)
+                    currentPage = await currentPage.nextPage();
+                else
+                    currentPage = await this.paginator();
+                itemIndex = 0;
+                if (currentPage.items.length == 0) {
+                    return { value: undefined, done: true };
+                }
+                else {
+                    if (prev?.items.length ?? 0 > 0) {
+                        if (this.repo.getEntityRef(prev.items[0]).getId() ==
+                            this.repo.getEntityRef(currentPage.items[0]).getId())
+                            throw new Error('pagination failure, returned same first row');
+                    }
+                }
+            }
+            if (itemIndex < currentPage.items.length)
+                return { value: currentPage.items[itemIndex++], done: false };
+            return { done: true, value: undefined };
+        };
+        return {
+            next: async () => {
+                let r = itStrategy();
+                return r;
+            },
+        };
+    }
+}
 class cacheEntityInfo {
     value = {};
     promise;