remult 0.27.20 → 0.27.21-next.6

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.post({
+                    await dApi.httpPost({
                         ...response,
                         created: (y) => {
                             const orig = { ...y };
@@ -324,7 +324,7 @@ export function remultGraphql(options) {
                                 [toCamelCase(getMetaType(meta))]: y,
                             });
                         },
-                    }, arg1.input);
+                    }, { get: () => undefined }, arg1.input, undefined);
                 });
                 resolversMutation[createResolverKey] = (origItem, args, req, gqlInfo) => root[createResolverKey](args, req, gqlInfo);
             }

package/esm/remult-mongo.js

@@ -266,7 +266,9 @@ class MongoEntityDataProvider {
         const { e, collection } = await this.collection();
         let f = new FilterConsumerBridgeToMongo(e);
         Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
-        collection.deleteOne(await f.resolveWhere(), { session: this.session });
+        await 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((c, req, res, orig) => dataApiFactory(c).httpGet(res, req, () => this.serializeContext(c))))
+            .get(this.process(async (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/column.js

@@ -3,11 +3,10 @@ import { getRepositoryInternals } from './remult3/repository-internals.js';
 export function makeTitle(name) {
     // insert a space before all caps
     return (name
-        .replace(/([A-Z])/g, ' $1')
-        // uppercase the first character
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        // Uppercase the first character
         .replace(/^./, (str) => str.toUpperCase())
-        .replace('Email', 'eMail')
-        .replace(' I D', ' ID'));
+        .replace('Email', 'eMail'));
 }
 export class LookupColumn {
     repository;

package/esm/src/data-api.js

@@ -20,7 +20,7 @@ export class DataApi {
             case 'count':
                 return this.count(res, req, undefined);
             case 'groupBy':
-                return this.groupBy(res, req, undefined);
+                return res.success(this.groupBy(req, undefined));
         }
         return this.getArray(res, req, undefined);
     }
@@ -34,31 +34,90 @@ export class DataApi {
                 };
             }
         }
-        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 this.groupBy(res, req, body);
-            case 'deleteMany':
-                validateWhereInBody();
-                return this.deleteMany(res, req, body);
-            case 'updateMany':
+        try {
+            if (action?.startsWith(liveQueryAction)) {
                 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);
+                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);
+        }
+    }
+    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);
         }
     }
     static defaultGetLimit = 0;
@@ -92,6 +151,7 @@ export class DataApi {
                 for await (const x of this.repository.query({
                     where,
                     include: this.includeNone(),
+                    aggregate: undefined,
                 })) {
                     await this.actualDelete(x);
                     deleted++;
@@ -103,7 +163,7 @@ export class DataApi {
             response.error(err, this.repository.metadata);
         }
     }
-    async groupBy(response, request, body) {
+    async groupBy(request, body) {
         let findOptions = await this.findOptionsFromRequest(request, body);
         let orderBy = {};
         if (body?.orderBy) {
@@ -146,9 +206,9 @@ export class DataApi {
                     x[f] = this.repository.fields.find(f).valueConverter.toJson(x[f]);
                 }
             });
-        response.success(result);
+        return result;
     }
-    async getArrayImpl(response, request, body) {
+    async getArrayImpl(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()));
@@ -224,7 +284,7 @@ export class DataApi {
             return;
         }
         try {
-            const { r } = await this.getArrayImpl(response, request, body);
+            const { r } = await this.getArrayImpl(request, body);
             response.success(r);
         }
         catch (err) {
@@ -240,7 +300,7 @@ export class DataApi {
             return;
         }
         try {
-            const r = await this.getArrayImpl(response, request, body);
+            const r = await this.getArrayImpl(request, body);
             const data = {
                 requestJson: await serializeContext(),
                 findOptionsJson: findOptionsToJson(r.findOptions, this.repository.metadata),
@@ -345,6 +405,7 @@ export class DataApi {
                 for await (const x of this.repository.query({
                     where,
                     include: this.includeNone(),
+                    aggregate: undefined,
                 })) {
                     await this.actualUpdate(x, body.set);
                     updated++;
@@ -383,35 +444,27 @@ export class DataApi {
             response.deleted();
         });
     }
-    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();
-                }
-                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);
+    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();
             }
-            else
-                response.created(await insert(body));
-        }
-        catch (err) {
-            if (err.isForbiddenError)
-                response.forbidden(err.message);
-            else
-                response.error(err, this.repository.metadata);
+            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));
+                }
+            });
+            return result;
         }
+        else
+            return await insert(body);
     }
 }
 export function determineSort(sortUrlParm, dirUrlParam) {

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

@@ -103,21 +103,24 @@ 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 = {
-            groupBy: options?.group?.map((x) => x.key),
-            sum: options?.sum?.map((x) => x.key),
-            avg: options?.avg?.map((x) => x.key),
-            min: options?.min?.map((x) => x.key),
-            max: options?.max?.map((x) => x.key),
-            distinctCount: options?.distinctCount?.map((x) => x.key),
-            orderBy: options?.orderBy?.map((x) => ({ ...x, field: x.field?.key })),
-        };
+        const body = this.buildAggregateOptions(options);
         const result = await run('groupBy', Object.keys(body).length > 0 ? body : undefined);
         if (options?.group)
             result.forEach((row) => {
@@ -127,6 +130,17 @@ export class RestEntityDataProvider {
             });
         return result;
     }
+    buildAggregateOptions(options) {
+        return {
+            groupBy: options?.group?.map((x) => x.key),
+            sum: options?.sum?.map((x) => x.key),
+            avg: options?.avg?.map((x) => x.key),
+            min: options?.min?.map((x) => x.key),
+            max: options?.max?.map((x) => x.key),
+            distinctCount: options?.distinctCount?.map((x) => x.key),
+            orderBy: options?.orderBy?.map((x) => ({ ...x, field: x.field?.key })),
+        };
+    }
     translateFromJson(row) {
         let result = {};
         for (const col of this.entity.fields) {
@@ -153,6 +167,13 @@ 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,14 +161,18 @@ export class RemultProxy {
             get metadata() {
                 return remultStatic.remultFactory().repo(...args).metadata;
             },
-            query: (...args2) => self
+            query: (options) => self
                 .remultFactory()
                 .repo(...args)
-                .query(...args2),
+                .query(options),
             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/QueryResultImpl.js

@@ -0,0 +1,147 @@
+import { queryConfig } from '../context.js';
+import { isOfType } from '../isOfType.js';
+import { Sort } from '../sort.js';
+import { RelationLoader } from './relation-loader.js';
+export 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;
+    _aggregates;
+    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 options = {
+            where: {
+                $and: [this.options.where, pNextPageFilter],
+            },
+            orderBy: this.options.orderBy,
+            limit: this.options.pageSize,
+            load: this.options.load,
+            include: this.options.include,
+        };
+        let getItems = () => this.repo.find(options);
+        if (this._aggregates === undefined &&
+            isOfType(this.options, 'aggregate')) {
+            let agg = this.options.aggregate;
+            if (!this.repo._dataProvider.isProxy) {
+                let itemsPromise = getItems();
+                getItems = async () => {
+                    this._aggregates = await this.repo.aggregate({
+                        ...agg,
+                        where: this.options.where,
+                    });
+                    this._count = this._aggregates.$count;
+                    return itemsPromise;
+                };
+            }
+            else {
+                const loader = new RelationLoader();
+                getItems = () => this.repo
+                    ._rawFind(options, false, loader, async (opt) => {
+                    const r = await this.repo._edp.query(opt, await this.repo.__buildGroupByOptions(agg));
+                    this._aggregates = r.aggregates;
+                    return r.items;
+                })
+                    .then(async (y) => {
+                    await loader.resolveAll();
+                    return y;
+                });
+            }
+        }
+        let items = await getItems();
+        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,
+            //@ts-ignore
+            aggregates: this._aggregates,
+        };
+    }
+    [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;
+            },
+        };
+    }
+}