remult 0.27.20-next.1 → 0.27.20-next.3

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/src/data-api.js

@@ -34,35 +34,69 @@ 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 res.success(this.groupBy(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;
-            case 'query':
-                return res.success(this.query(res, req, body));
-            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();
@@ -410,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

@@ -105,9 +105,14 @@ export class RestEntityDataProvider {
     }
     query(options, aggregateOptions) {
         const r = this.buildFindRequest(options);
-        return r.run('query', {
+        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({
@@ -162,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

@@ -169,6 +169,10 @@ export class RemultProxy {
                 .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

@@ -1,4 +1,5 @@
 import { queryConfig } from '../context.js';
+import { isOfType } from '../isOfType.js';
 import { Sort } from '../sort.js';
 import { RelationLoader } from './relation-loader.js';
 export class QueryResultImpl {
@@ -52,11 +53,8 @@ export class QueryResultImpl {
             include: this.options.include,
         };
         let getItems = () => this.repo.find(options);
-        if (this._aggregates === undefined /* &&
-        (isOfType<QueryOptions<entityType, any, any, any, any, any>>(
-          this.options,
-          'aggregate',
-        ))*/) {
+        if (this._aggregates === undefined &&
+            isOfType(this.options, 'aggregate')) {
             let agg = this.options.aggregate;
             if (!this.repo._dataProvider.isProxy) {
                 let itemsPromise = getItems();
@@ -65,6 +63,7 @@ export class QueryResultImpl {
                         ...agg,
                         where: this.options.where,
                     });
+                    this._count = this._aggregates.$count;
                     return itemsPromise;
                 };
             }

package/esm/src/remult3/RepositoryImplementation.js

@@ -350,10 +350,22 @@ 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), set);
+            return this._edp.updateMany(await this._translateWhereToFilter(where), this.__createDto({ ...set }));
         }
         else {
             let updated = 0;
@@ -406,6 +418,40 @@ 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) {
@@ -1460,11 +1506,9 @@ 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;
             }

package/esm/src/remult3/remult3.js

@@ -17,16 +17,14 @@ const wnn = [
 export const flags = {
     error500RetryCount: 4,
 };
-//p1 - add aggregate to query
-//p1 - consider upsert (where,set)
-//p1 - add parameter all to deleteMany, and updateMany
-//p1  filter.apply ApiPreFilter
+//p2 - add parameter all to deleteMany, and updateMany
+//p2  filter.apply ApiPreFilter
 //p2 - signIn: (arg) =>withRemult(async () => { - consider if there's a generic way of doing signIn:withRemult(arg=>{})
-/*p1 - add id and use uuid by default, but allow changes with Fields.id.defaultIdProvider NO but defaultProvider yes???
-  //p1 - replace uuid with crypto.randomUUID and allow custom fallback NO
-  //p1 - Add example for luid
-  //p1 - add example for nanoid
-  //p1 - explain the benefits of changing the default provider for testing in docs.
+/*p2 - add id and use uuid by default, but allow changes with Fields.id.defaultIdProvider NO but defaultProvider yes???
+  //p2 - replace uuid with crypto.randomUUID and allow custom fallback NO
+  //p2 - Add example for luid
+  //p2 - add example for nanoid
+  //p2 - explain the benefits of changing the default provider for testing in docs.
 */
 //p2 - add some kind of options handler that will help with translation etc... like in hagai - something that runs at the stage where options are being built
 //p2 - enforce api rules in some backend scenarios - https://discord.com/channels/975754286384418847/1292424895338119239
@@ -38,13 +36,11 @@ export const flags = {
 */
 //p2 - fix query docs to also explain how it can be used for infinite scroll and pagination.
 //p2 - when like doesn't have a string - don't send it to the db
-//p1 - vite 5.3 supports ts5 decorators - check and adapt.
-//p1 - tutorial about controller - and mutable controller
-//p1 - docs abount subscription channel
-//p1 - Consider enforcing serial operations on JSON database to prevent data loss
-//p1 - add LifecycleEvent to documentation
-//p1 - fix chaining of saving and saved in multiple entity options args
-//p1 - review starter and examples and separate remult * auth from the routes
+//p2 - vite 5.3 supports ts5 decorators - check and adapt.
+//p2 - tutorial about controller - and mutable controller
+//p2 - docs abount subscription channel
+//p2 - add LifecycleEvent to documentation
+//p2 - fix chaining of saving and saved in multiple entity options args
 //y1 - live query with count #436
 //y1 TODO - In the esm version of our tutorial - the imports are automatically .ts and not .js in react and not in vue
 //y1 TODO - fix remult admin not to load the html into memory until used
@@ -66,12 +62,10 @@ const result = await repo.batch(x=>({
 */
 //y1 - wait a second to close stream -see pr
 //p1 - prepare the createEntity discussion
-//p1 - article on displayValue including it's definition for entities that is used in relations
-//p1 - article auth.js with express - played with it, requires type="module" and a few more configurations - https://github.com/noam-honig/express-auth
-//p2 - create foreign key constraints in user code - https://codesandbox.io/p/devbox/fk-validator-tdshcs
+//p2 - article on displayValue including it's definition for entities that is used in relations
+//p2 - create foreign key constraints in user code - https://codesandbox.io/p/devbox/fk-validator-tdshcs, https://gist.github.com/jycouet/8b264e18c4d8605736f4353062a7d81e
 //y2 - should we validate relations
 //y1 - dependency of live query tables  live query refresh of view on table update
-//p1 - see why mongo tests do not run anymore
 //y2 - consider replacing all errors with error classes that extend the base Error class
 //y2 - should enforce integer - currently we probably round / truncate it
 //y1 - talk about filter on objects that are not loaded -  {
@@ -100,11 +94,9 @@ const result = await repo.batch(x=>({
 //y2 - constraints (@JY)
 //p1 - when a tasks table exists in a different schema - we get many errors
 //p1 - live query with include
-//p1 - adjust angular tutorial starter kit for latest angular (as is in tutorial)
 //y2 - Fix problem with promise all in sql expression recurssion - when using PromiseAll in row relation loading, some sql expressions appear is recursion call even if they are not
 //p2 - when subscribe is forbidden - the query still runs after the renew process
 //p2 - 'update tasks set  where id = $1
-//y2 - remove __dirname from tutorials
 //p2 - when value changes for field with error, clear error - so the user will feel comfortable
 //p2 - allowApiUpdate should be false for include in api false
 //docs

package/graphql.js

@@ -392,14 +392,14 @@ function remultGraphql(options) {
                 root[createResolverKey_1] = handleMutationWithErrors_1(function (dApi, response, setResult, arg1, req) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                     return tslib_1.__generator(this, function (_a) {
                         switch (_a.label) {
-                            case 0: return [4 /*yield*/, dApi.post(tslib_1.__assign(tslib_1.__assign({}, response), { created: function (y) {
+                            case 0: return [4 /*yield*/, dApi.httpPost(tslib_1.__assign(tslib_1.__assign({}, response), { created: function (y) {
                                         var _a;
                                         var orig = tslib_1.__assign({}, y);
                                         currentType.query.resultProcessors.forEach(function (z) { return z(y, orig); });
                                         setResult((_a = {},
                                             _a[toCamelCase(getMetaType(meta))] = y,
                                             _a));
-                                    } }), arg1.input)];
+                                    } }), { get: function () { return undefined; } }, arg1.input, undefined)];
                             case 1:
                                 _a.sent();
                                 return [2 /*return*/];

package/package.json

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

package/remult-mongo.js

@@ -529,8 +529,11 @@ var MongoEntityDataProvider = /** @class */ (function () {
                         index_js_1.Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
                         _c = (_b = collection).deleteOne;
                         return [4 /*yield*/, f.resolveWhere()];
-                    case 2:
-                        _c.apply(_b, [_d.sent(), { session: this.session }]);
+                    case 2: return [4 /*yield*/, _c.apply(_b, [_d.sent(), {
+                                session: this.session,
+                            }])];
+                    case 3:
+                        _d.sent();
                         return [2 /*return*/];
                 }
             });

package/src/data-api.d.ts

@@ -8,6 +8,7 @@ export declare class DataApi<T = unknown> {
     constructor(repository: Repository<T>, remult: Remult);
     httpGet(res: DataApiResponse, req: DataApiRequest, serializeContext: () => Promise<any>): void | Promise<void>;
     httpPost(res: DataApiResponse, req: DataApiRequest, body: any, serializeContext: () => Promise<any>): Promise<void>;
+    upsertMany(response: DataApiResponse, request: DataApiRequest, body: any): Promise<void>;
     query(response: DataApiResponse, request: DataApiRequest, body: any): Promise<{
         items: any[];
         aggregates: import("./remult3/remult3.js").GroupByResult<T, any[], any[], any[], any[], any[], any[]>;
@@ -36,7 +37,7 @@ export declare class DataApi<T = unknown> {
     put(response: DataApiResponse, id: any, body: any): Promise<void>;
     actualDelete(row: any): Promise<void>;
     delete(response: DataApiResponse, id: any): Promise<void>;
-    post(response: DataApiResponse, body: any): Promise<void>;
+    post(body: any): Promise<any>;
 }
 export interface DataApiResponse {
     success(data: any): void;