proto.io 0.0.171 → 0.0.173

package/dist/adapters/storage/progres.mjs

@@ -483,7 +483,7 @@ class QueryCompiler {
       INSERT INTO ${{ identifier: options.className }}
       (${_.map(keys, x => sql `${{ identifier: x }}`)})
       VALUES ${_.map(_values, v => sql `(${_.map(keys, k => sql `${v[k]}`)})`)}
-      RETURNING 0
+      RETURNING _id
     `;
     }
     updateOne(query, update) {
@@ -501,6 +501,17 @@ class QueryCompiler {
         `;
         });
     }
+    updateMany(query, update) {
+        return this._modifyQuery(query, (fetchName) => {
+            return sql `
+          UPDATE ${{ identifier: query.className }}
+          SET __v = __v + 1, _updated_at = NOW()
+          ${!_.isEmpty(update) ? sql `, ${this._encodeUpdateAttrs(query.className, update)}` : sql ``}
+          WHERE ${{ identifier: query.className }}._id IN (SELECT ${{ identifier: fetchName }}._id FROM ${{ identifier: fetchName }})
+          RETURNING _id
+        `;
+        });
+    }
     upsertOne(query, update, setOnInsert) {
         const _insert = _.toPairs({
             ..._defaultInsertOpts(query),
@@ -534,6 +545,35 @@ class QueryCompiler {
         `;
         });
     }
+    upsertMany(query, update, setOnInsert) {
+        const _insert = _.toPairs({
+            ..._defaultInsertOpts(query),
+            ...this._encodeObjectAttrs(query.className, setOnInsert),
+        });
+        return this._modifyQuery(query, (fetchName) => {
+            const updateName = `_update_$${query.className.toLowerCase()}`;
+            const insertName = `_insert_$${query.className.toLowerCase()}`;
+            return sql `
+          , ${{ identifier: updateName }} AS (
+            UPDATE ${{ identifier: query.className }}
+            SET __v = __v + 1, _updated_at = NOW()
+            ${!_.isEmpty(update) ? sql `, ${this._encodeUpdateAttrs(query.className, update)}` : sql ``}
+            WHERE ${{ identifier: query.className }}._id IN (SELECT ${{ identifier: fetchName }}._id FROM ${{ identifier: fetchName }})
+            RETURNING _id, 0 AS ${{ identifier: 'result' }}
+          )
+          , ${{ identifier: insertName }} AS (
+            INSERT INTO ${{ identifier: query.className }}
+            (${_.map(_insert, x => sql `${{ identifier: x[0] }}`)})
+            SELECT ${_.map(_insert, x => sql `${x[1]} AS ${{ identifier: x[0] }}`)}
+            WHERE NOT EXISTS(SELECT * FROM ${{ identifier: updateName }})
+            RETURNING _id, 1 AS ${{ identifier: 'result' }}
+          )
+          SELECT * FROM ${{ identifier: updateName }}
+          UNION
+          SELECT * FROM ${{ identifier: insertName }}
+        `;
+        });
+    }
     deleteOne(query) {
         return this._modifyQuery({ ...query, limit: 1 }, (fetchName, context) => {
             const name = `_delete_$${query.className.toLowerCase()}`;
@@ -560,7 +600,7 @@ class QueryCompiler {
         return this._modifyQuery(query, (fetchName) => sql `
         DELETE FROM ${{ identifier: query.className }}
         WHERE ${{ identifier: query.className }}._id IN (SELECT ${{ identifier: fetchName }}._id FROM ${{ identifier: fetchName }})
-        RETURNING 0
+        RETURNING _id
       `);
     }
 }
@@ -754,11 +794,24 @@ class SqlStorage {
         const updated = _.first(await this.query(compiler.updateOne(query, update)));
         return _.isNil(updated) ? undefined : this._decodeObject(query.className, updated);
     }
+    async updateMany(query, update) {
+        const compiler = this._makeCompiler(true, query.extraFilter);
+        const updated = await this.query(compiler.updateMany(query, update));
+        return updated.length;
+    }
     async upsertOne(query, update, setOnInsert) {
         const compiler = this._makeCompiler(true, query.extraFilter);
         const upserted = _.first(await this.query(compiler.upsertOne(query, update, setOnInsert)));
         return _.isNil(upserted) ? undefined : this._decodeObject(query.className, upserted);
     }
+    async upsertMany(query, update, setOnInsert) {
+        const compiler = this._makeCompiler(true, query.extraFilter);
+        const upserted = await this.query(compiler.upsertMany(query, update, setOnInsert));
+        return {
+            updated: _.filter(upserted, x => x.result === 0).length,
+            inserted: _.filter(upserted, x => x.result === 1).length,
+        };
+    }
     async deleteOne(query) {
         const compiler = this._makeCompiler(true, query.extraFilter);
         const deleted = _.first(await this.query(compiler.deleteOne(query)));
@@ -2104,7 +2157,9 @@ const encodeFieldExpression = (compiler, parent, field, expr) => {
                     break;
                 if (_.isNil(expr.value))
                     return sql `${element} IS NULL`;
-                if (!_.isString(dataType) && dataType?.type === 'pointer' && expr.value instanceof TObject && expr.value.objectId) {
+                if (!_.isString(dataType) && dataType?.type === 'pointer') {
+                    if (!(expr.value instanceof TObject) || dataType.target !== expr.value.className || !expr.value.objectId)
+                        break;
                     return sql `${element} ${nullSafeEqual()} ${{ value: expr.value.objectId }}`;
                 }
                 return sql `${element} ${nullSafeEqual()} ${encodeValue(expr.value)}`;
@@ -2115,7 +2170,9 @@ const encodeFieldExpression = (compiler, parent, field, expr) => {
                     break;
                 if (_.isNil(expr.value))
                     return sql `${element} IS NOT NULL`;
-                if (!_.isString(dataType) && dataType?.type === 'pointer' && expr.value instanceof TObject && expr.value.objectId) {
+                if (!_.isString(dataType) && dataType?.type === 'pointer') {
+                    if (!(expr.value instanceof TObject) || dataType.target !== expr.value.className || !expr.value.objectId)
+                        break;
                     return sql `${element} ${nullSafeNotEqual()} ${{ value: expr.value.objectId }}`;
                 }
                 return sql `${element} ${nullSafeNotEqual()} ${encodeValue(expr.value)}`;
@@ -2191,7 +2248,7 @@ const encodeFieldExpression = (compiler, parent, field, expr) => {
                             if (!_.isString(dataType) && dataType?.type === 'pointer') {
                                 if (_.isNil(value))
                                     return sql `${element} IS NULL`;
-                                if (!(value instanceof TObject) || !value.objectId)
+                                if (!(value instanceof TObject) || dataType.target !== value.className || !value.objectId)
                                     break;
                                 return sql `${element} ${nullSafeEqual()} ${{ value: value.objectId }}`;
                             }
@@ -2201,7 +2258,7 @@ const encodeFieldExpression = (compiler, parent, field, expr) => {
                         const containsNil = _.some(expr.value, x => _.isNil(x));
                         const values = _.filter(expr.value, x => !_.isNil(x));
                         if (!_.isString(dataType) && dataType?.type === 'pointer') {
-                            if (!_.every(values, x => x instanceof TObject && x.objectId))
+                            if (!_.every(values, x => x instanceof TObject && dataType.target === x.className && x.objectId))
                                 break;
                             if (containsNil) {
                                 return sql `${element} IS NULL OR ${element} IN (${_.map(values, (x) => sql `${{ value: x.objectId }}`)})`;
@@ -2227,7 +2284,7 @@ const encodeFieldExpression = (compiler, parent, field, expr) => {
                             if (!_.isString(dataType) && dataType?.type === 'pointer') {
                                 if (_.isNil(value))
                                     return sql `${element} IS NOT NULL`;
-                                if (!(value instanceof TObject) || !value.objectId)
+                                if (!(value instanceof TObject) || dataType.target !== value.className || !value.objectId)
                                     break;
                                 return sql `${element} ${nullSafeNotEqual()} ${{ value: value.objectId }}`;
                             }
@@ -2237,7 +2294,7 @@ const encodeFieldExpression = (compiler, parent, field, expr) => {
                         const containsNil = _.some(expr.value, x => _.isNil(x));
                         const values = _.filter(expr.value, x => !_.isNil(x));
                         if (!_.isString(dataType) && dataType?.type === 'pointer') {
-                            if (!_.every(values, x => x instanceof TObject && x.objectId))
+                            if (!_.every(values, x => x instanceof TObject && dataType.target === x.className && x.objectId))
                                 break;
                             if (containsNil) {
                                 return sql `${element} IS NOT NULL AND ${element} NOT IN (${_.map(values, (x) => sql `${{ value: x.objectId }}`)})`;
@@ -2272,7 +2329,7 @@ const encodeFieldExpression = (compiler, parent, field, expr) => {
                     return sql `${element} ${{ literal: op }} ${{ value: _encodeValue(expr.value) }}`;
                 }
                 if (relation && parent.className) {
-                    if (!_.every(expr.value, x => x instanceof TObject && x.objectId))
+                    if (!_.every(expr.value, x => x instanceof TObject && relation.target === x.className && x.objectId))
                         break;
                     const tempName = `_populate_expr_$${compiler.nextIdx()}`;
                     const populate = _selectRelationPopulate(compiler, { className: parent.className, name: parent.name }, relation.populate, `$${field}`, false);