remult 0.27.19 → 0.27.20-next.0

package/esm/index.js

@@ -11,6 +11,7 @@ export { SqlDatabase } from './src/data-providers/sql-database.js'; //V
 export { CustomSqlFilterBuilder, dbNamesOf, } from './src/filter/filter-consumer-bridge-to-sql-request.js';
 export { JsonDataProvider, } from './src/data-providers/json-data-provider.js'; //V
 export { JsonEntityOpfsStorage } from './src/data-providers/json-entity-opfs-storage.js';
+export { JsonEntityIndexedDbStorage } from './src/data-providers/json-entity-indexed-db-data-provider.js';
 //export * from './src/data-api'; //reconsider if to make internal
 export { Controller, BackendMethod, ProgressListener, ForbiddenError, } from './src/server-action.js';
 export { Allow, Remult, withRemult, isBackend, EventSource, } from './src/context.js';

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/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);
     }
@@ -46,7 +46,7 @@ export class DataApi {
                 validateWhereInBody();
                 return this.count(res, req, body);
             case 'groupBy':
-                return this.groupBy(res, req, body);
+                return res.success(this.groupBy(req, body));
             case 'deleteMany':
                 validateWhereInBody();
                 return this.deleteMany(res, req, body);
@@ -57,10 +57,35 @@ export class DataApi {
                 await this.remult.liveQueryStorage.remove(body.id);
                 res.success('ok');
                 return;
+            case 'query':
+                return res.success(this.query(res, req, body));
             default:
                 return this.post(res, body);
         }
     }
+    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;
     async get(response, id) {
         if (!this.repository.metadata.apiReadAllowed) {
@@ -92,6 +117,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 +129,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 +172,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 +250,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 +266,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 +371,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++;

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

@@ -30,9 +30,11 @@ class JsonEntityDataProvider {
         let dbName = await this.entity.dbName;
         let s = await this.helper.getItem(dbName);
         if (s)
-            data = JSON.parse(s);
+            data = this.helper.supportsRawJson ? s : JSON.parse(s);
         let dp = new ArrayEntityDataProvider(this.entity, () => data);
-        return what(dp, async () => await this.helper.setItem(dbName, JSON.stringify(data, undefined, this.formatted ? 2 : undefined)));
+        return what(dp, async () => await this.helper.setItem(dbName, this.helper.supportsRawJson
+            ? data
+            : JSON.stringify(data, undefined, this.formatted ? 2 : undefined)));
     }
     p = Promise.resolve();
     find(options) {

package/esm/src/data-providers/json-entity-indexed-db-data-provider.js

@@ -0,0 +1,55 @@
+export class JsonEntityIndexedDbStorage {
+    dbName;
+    storeName;
+    constructor(dbName = 'db', storeName = 'jsonStore') {
+        this.dbName = dbName;
+        this.storeName = storeName;
+    }
+    supportsRawJson = true;
+    //@internal
+    db;
+    async getItem(entityDbName) {
+        return new Promise(async (resolve, reject) => {
+            const transaction = (await this.init()).transaction([this.storeName], 'readonly');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.get(entityDbName);
+            request.onerror = (event) => reject(request.error);
+            request.onsuccess = (event) => {
+                if (request.result) {
+                    resolve(request.result);
+                }
+                else {
+                    resolve(null);
+                }
+            };
+        });
+    }
+    //@internal
+    async init() {
+        if (!this.db) {
+            this.db = await new Promise((resolve, reject) => {
+                let db;
+                const request = indexedDB.open(this.dbName, 1);
+                request.onerror = (event) => reject(request.error);
+                request.onsuccess = (event) => {
+                    db = request.result;
+                    resolve(db);
+                };
+                request.onupgradeneeded = (event) => {
+                    db = request.result;
+                    db.createObjectStore(this.storeName);
+                };
+            });
+        }
+        return this.db;
+    }
+    async setItem(entityDbName, json) {
+        return new Promise(async (resolve, reject) => {
+            const transaction = (await this.init()).transaction([this.storeName], 'readwrite');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.put(json, entityDbName);
+            request.onerror = (event) => reject(request.error);
+            request.onsuccess = (event) => resolve();
+        });
+    }
+}

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

@@ -103,21 +103,19 @@ 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),
+        });
+    }
     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 +125,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) {

package/esm/src/remult-proxy.js

@@ -161,10 +161,10 @@ 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)

package/esm/src/remult3/QueryResultImpl.js

@@ -0,0 +1,146 @@
+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,
+                    });
+                    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;
+            },
+        };
+    }
+}

package/esm/src/remult3/RepositoryImplementation.js

@@ -1,6 +1,6 @@
 import { LookupColumn, makeTitle } from '../column.js';
 import { CompoundIdField } from '../CompoundIdField.js';
-import { Remult, isBackend, queryConfig } from '../context.js';
+import { Remult, isBackend } from '../context.js';
 import { Filter } from '../filter/filter-interfaces.js';
 import { Sort } from '../sort.js';
 import { GroupByForApiKey, } from './remult3.js';
@@ -18,6 +18,7 @@ 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())
@@ -132,6 +133,23 @@ 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,
         });
@@ -185,20 +203,7 @@ export class RepositoryImplementation {
                 }
             }
         }
-        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;
+        return dpOptions;
     }
     _idCache = new Map();
     _getCachedById(id, doNotLoadIfNotFound) {
@@ -352,7 +357,7 @@ export class RepositoryImplementation {
         }
         else {
             let updated = 0;
-            for await (const item of this.query({ where })) {
+            for await (const item of this.query({ where, aggregate: undefined })) {
                 assign(item, set);
                 await getEntityRef(item).save();
                 updated++;
@@ -465,7 +470,7 @@ export class RepositoryImplementation {
             },
         };
     }
-    async _rawFind(options, skipOrderByAndLimit = false, loader) {
+    async _rawFind(options, skipOrderByAndLimit = false, loader, actualFind) {
         if (!options)
             options = {};
         if (this._defaultFindOptions) {
@@ -477,13 +482,13 @@ export class RepositoryImplementation {
             delete opt.limit;
         }
         Remult.onFind(this._info, options);
-        const rawRows = await this._edp.find(opt);
+        const rawRows = await actualFind(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);
+        const result = await this._rawFind(options, skipOrderByAndLimit, loader, (x) => this._edp.find(x));
         await loader.resolveAll();
         return result;
     }
@@ -578,7 +583,7 @@ export class RepositoryImplementation {
                         loader
                             .load({
                             entityType,
-                            find: (options) => toRepo._rawFind(options, false, loader),
+                            find: (options) => toRepo._rawFind(options, false, loader, (o) => toRepo._edp.find(o)),
                             metadata: toRepo.metadata,
                         }, findOptions)
                             .then((result) => {
@@ -729,7 +734,7 @@ export class RepositoryImplementation {
         }
         else {
             let deleted = 0;
-            for await (const item of this.query({ where })) {
+            for await (const item of this.query({ where, aggregate: undefined })) {
                 await getEntityRef(item).delete();
                 deleted++;
             }
@@ -2380,116 +2385,6 @@ 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;