@oneuptime/common 13.0.5 → 13.0.7

package/build/dist/Server/Services/DatabaseService.js

@@ -46,6 +46,7 @@ import OneUptimeDate from "../../Types/Date";
 import BadDataException from "../../Types/Exception/BadDataException";
 import DatabaseNotConnectedException from "../../Types/Exception/DatabaseNotConnectedException";
 import HashedString from "../../Types/HashedString";
+import { ObjectType } from "../../Types/JSON";
 import JSONFunctions from "../../Types/JSONFunctions";
 import ObjectID from "../../Types/ObjectID";
 import TelemetryContext from "../Utils/Telemetry/TelemetryContext";
@@ -61,6 +62,7 @@ import { EntityManager, } from "typeorm";
 import Realtime from "../Utils/Realtime";
 import ModelEventType from "../../Types/Realtime/ModelEventType";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import RelationValueUtil from "../Utils/Database/RelationValueUtil";
 const RULE_CRITERIA_RELATION_OPERATORS = new Set([
     RuleCriteriaOperator.HasAnyOf,
     RuleCriteriaOperator.HasAllOf,
@@ -215,6 +217,56 @@ class DatabaseService extends BaseService {
         }
         return await this.onBeforeCreate(createBy);
     }
+    /*
+     * BasicForm wraps every FormFieldSchemaType.Password value in a HashedString
+     * before submit, so a model form can post one straight at a hashed column.
+     * The same field also collects secrets that are stored rather than hashed —
+     * a TAXII feed token, data source credentials, a webhook signing secret —
+     * and those columns want the string the user typed. Left wrapped, encrypt()
+     * walked the HashedString's own fields as if it were a JSON column, and the
+     * Postgres driver serialized the object through toJSON(), so the column
+     * held '{"_type":"HashedString","value":"<ciphertext>"}' instead of the
+     * ciphertext. https://github.com/OneUptime/oneuptime/issues/3807
+     *
+     * Runs before the hooks, so they validate the same string that is saved.
+     */
+    unwrapHashedStringsForUnhashedColumns(data) {
+        for (const columnName of Object.keys(data)) {
+            const value = data[columnName];
+            if (value instanceof HashedString &&
+                this.model.isTableColumn(columnName) &&
+                !this.model.isHashedStringColumn(columnName)) {
+                data[columnName] = value.toString();
+            }
+        }
+    }
+    /*
+     * Rows written before the fix above hold their ciphertext inside that
+     * HashedString envelope. Decrypting the envelope itself is not just wrong
+     * but random — it carries no OpenSSL salt, so crypto-js derives the key
+     * from a fresh random one on every call and returns "" or throws
+     * "Malformed UTF-8 data". A ciphertext is base64 and never starts with
+     * "{", so the envelope is unambiguous: unwrap it and those rows decrypt
+     * without anyone re-entering the secret.
+     */
+    static unwrapHashedStringEnvelope(storedValue) {
+        if (typeof storedValue !== "string" || !storedValue.startsWith("{")) {
+            return storedValue;
+        }
+        try {
+            const parsed = JSON.parse(storedValue);
+            if (parsed &&
+                typeof parsed === Typeof.Object &&
+                parsed["_type"] === ObjectType.HashedString &&
+                typeof parsed["value"] === Typeof.String) {
+                return parsed["value"];
+            }
+        }
+        catch (_a) {
+            // Not JSON, so not the envelope.
+        }
+        return storedValue;
+    }
     async encrypt(data) {
         for (const key of this.model.getEncryptedColumns().columns) {
             if (!data[key]) {
@@ -384,7 +436,7 @@ class DatabaseService extends BaseService {
             }
             else {
                 //If its string or other type.
-                data.setValue(key, await Encryption.decrypt(data[key]));
+                data.setValue(key, await Encryption.decrypt(DatabaseService.unwrapHashedStringEnvelope(data[key])));
             }
         }
         return data;
@@ -902,6 +954,7 @@ class DatabaseService extends BaseService {
     }
     async create(createBy) {
         var _a, _b;
+        this.unwrapHashedStringsForUnhashedColumns(createBy.data);
         const onCreate = createBy.props.ignoreHooks
             ? { createBy, carryForward: [] }
             : await this._onBeforeCreate(createBy);
@@ -930,6 +983,7 @@ class DatabaseService extends BaseService {
         createBy.data = data;
         // check uniqueColumns by:
         createBy = await this.checkUniqueColumnBy(createBy);
+        await this.checkUniqueColumnsTogether(createBy.data);
         // serialize.
         createBy.data = (await this.sanitizeCreateOrUpdate(createBy.data, createBy.props));
         try {
@@ -1043,8 +1097,14 @@ class DatabaseService extends BaseService {
             return;
         }
         try {
+            /*
+             * A new row every time. getModel() is the owner service's own shared
+             * instance, and a save writes the generated _id back onto whatever it
+             * was handed - so reusing it would turn the next auto-owner insert into
+             * an update of this row.
+             */
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const ownerModel = entry.ownerUserService.getModel();
+            const ownerModel = new entry.ownerUserService.modelType();
             ownerModel[entry.fkColumn] = resourceId;
             ownerModel.userId = props.userId;
             ownerModel.projectId = projectId;
@@ -1054,6 +1114,13 @@ class DatabaseService extends BaseService {
             });
         }
         catch (err) {
+            /*
+             * The create form can name the creator as an owner too, and that path
+             * may have added them first. They are an owner either way.
+             */
+            if (PostgresErrorTranslator.isUniqueViolation(err)) {
+                return;
+            }
             logger.error(`auto-owner-on-create failed for ${modelName} ${resourceId.toString()}`);
             logger.error(err);
         }
@@ -1175,6 +1242,62 @@ class DatabaseService extends BaseService {
         }
         return Promise.resolve(createBy);
     }
+    /*
+     * Enforces @UniqueColumnsTogether before the row is written, so a duplicate
+     * is rejected with the model's own message and never reaches
+     * onCreateSuccess (and whatever feed items or notifications it sends).
+     *
+     * A key column can arrive as its id column (`teamId`) or only as the
+     * relation that fills it (`team`), so both are read. When a value is
+     * missing altogether there is nothing to compare; the unique index decides.
+     */
+    async checkUniqueColumnsTogether(data) {
+        for (const constraint of this.model.getUniqueColumnsTogether()) {
+            const query = {};
+            let isKeyComplete = true;
+            for (const columnName of constraint.columnNames) {
+                const value = this.getUniqueKeyValue(data, columnName);
+                if (value === null) {
+                    isKeyComplete = false;
+                    break;
+                }
+                query[columnName] = value;
+            }
+            if (!isKeyComplete) {
+                continue;
+            }
+            const count = await this.countBy({
+                query: query,
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (count.toNumber() > 0) {
+                throw PostgresErrorTranslator.createUniqueViolationException(constraint.errorMessage);
+            }
+        }
+    }
+    getUniqueKeyValue(data, columnName) {
+        const metadata = this.model.getTableColumnMetadata(columnName);
+        if ((metadata === null || metadata === void 0 ? void 0 : metadata.type) !== TableColumnType.ObjectID) {
+            const value = data[columnName];
+            return value === undefined || value === null ? null : value;
+        }
+        let id = RelationValueUtil.getRelationId(data[columnName]);
+        if (!id) {
+            const relationColumnName = this.model
+                .getTableColumns()
+                .columns.find((column) => {
+                const relationMetadata = this.model.getTableColumnMetadata(column);
+                return (relationMetadata.type === TableColumnType.Entity &&
+                    relationMetadata.manyToOneRelationColumn === columnName);
+            });
+            if (relationColumnName) {
+                id = RelationValueUtil.getRelationId(data[relationColumnName]);
+            }
+        }
+        return id ? new ObjectID(id) : null;
+    }
     async countBy({ query, skip, limit, props, groupBy, distinctOn, }) {
         try {
             if (groupBy && Object.keys(groupBy).length > 0) {
@@ -1948,6 +2071,7 @@ class DatabaseService extends BaseService {
         try {
             this.setTelemetryContextFromProps(updateBy.props);
             updateBy.data = this.sanitizeUpdateData(updateBy.data);
+            this.unwrapHashedStringsForUnhashedColumns(updateBy.data);
             const onUpdate = updateBy.props.ignoreHooks
                 ? { updateBy, carryForward: [] }
                 : await this.onBeforeUpdate(updateBy);
@@ -1990,23 +2114,8 @@ class DatabaseService extends BaseService {
                 selectColumns[this.getModel().getTenantColumn().toString()] =
                     true;
             }
-            /*
-             * When audit logging on update is enabled, ensure the resource's display
-             * name is loaded on the `before` snapshot so the audit entry records the
-             * human-readable resource name even when the update doesn't touch it.
-             */
             if ((_a = this.getModel().enableAuditLogOn) === null || _a === void 0 ? void 0 : _a.update) {
-                const nameCandidates = [
-                    "name",
-                    "title",
-                    "displayName",
-                ];
-                const modelColumns = this.getModel().getTableColumns().columns;
-                for (const candidate of nameCandidates) {
-                    if (modelColumns.includes(candidate)) {
-                        selectColumns[candidate] = true;
-                    }
-                }
+                this.addAuditLogColumnsToUpdateSelect(selectColumns, dataKeys);
             }
             const items = hasColumnsToUpdate
                 ? await this._findBy({
@@ -2199,6 +2308,53 @@ class DatabaseService extends BaseService {
             throw this.getException(error);
         }
     }
+    /*
+     * The `before` row an update loads is sparse on purpose - the columns the
+     * write touches, plus `_id` and the tenant column - so everything
+     * AuditLogService reads off it has to be requested here:
+     *   - the resource's display name, even when the update does not touch it;
+     *   - the parent id a child's entries roll up to (rootResource);
+     *   - the id of the row that names a nameless row (resourceNameRelation);
+     *   - the related rows' names for relation columns the write touches, so
+     *     the diff reads "Production -> Staging" rather than as two ids. A
+     *     relation selected as `true` loads only `_id`.
+     */
+    addAuditLogColumnsToUpdateSelect(select, dataKeys) {
+        var _a, _b;
+        const model = this.getModel();
+        const auditLogOn = model.enableAuditLogOn;
+        const selectRecord = select;
+        for (const candidate of ["name", "title", "displayName"]) {
+            if (model.isTableColumn(candidate)) {
+                selectRecord[candidate] = true;
+            }
+        }
+        const rootColumn = (_a = auditLogOn === null || auditLogOn === void 0 ? void 0 : auditLogOn.rootResource) === null || _a === void 0 ? void 0 : _a.column;
+        if (rootColumn && model.isTableColumn(rootColumn)) {
+            selectRecord[rootColumn] = true;
+        }
+        const nameRelation = auditLogOn === null || auditLogOn === void 0 ? void 0 : auditLogOn.resourceNameRelation;
+        if (nameRelation && model.isTableColumn(nameRelation)) {
+            const nameRelationIdColumn = (_b = model.getTableColumnMetadata(nameRelation)) === null || _b === void 0 ? void 0 : _b.manyToOneRelationColumn;
+            if (nameRelationIdColumn && model.isTableColumn(nameRelationIdColumn)) {
+                selectRecord[nameRelationIdColumn] = true;
+            }
+        }
+        for (const key of dataKeys) {
+            if (!model.isTableColumn(key)) {
+                continue;
+            }
+            const metadata = model.getTableColumnMetadata(key);
+            if (!(metadata === null || metadata === void 0 ? void 0 : metadata.modelType) ||
+                (metadata.type !== TableColumnType.EntityArray &&
+                    metadata.type !== TableColumnType.Entity)) {
+                continue;
+            }
+            selectRecord[key] = new metadata.modelType().isTableColumn("name")
+                ? { _id: true, name: true }
+                : { _id: true };
+        }
+    }
     hasSameValues(data) {
         var _a;
         const { item, updatedItem } = data;
@@ -2206,7 +2362,27 @@ class DatabaseService extends BaseService {
         for (const column of columns) {
             const currentValue = item.getColumnValue(column);
             const updatedValue = updatedItem[column];
-            const isJSONColumn = ((_a = item.getTableColumnMetadata(column)) === null || _a === void 0 ? void 0 : _a.type) === TableColumnType.JSON;
+            const columnType = (_a = item.getTableColumnMetadata(column)) === null || _a === void 0 ? void 0 : _a.type;
+            const isJSONColumn = columnType === TableColumnType.JSON;
+            /*
+             * A relation value is a model instance (or an array of them), and those
+             * stringify as "[object Object]" too - so swapping a resource's labels
+             * A,B for C,D compared as unchanged, and the update fired neither its
+             * workflow nor its audit entry. Compare the referenced ids, as sets:
+             * the order a relation comes back in means nothing. When either side
+             * has no ids to compare (the relation was not loaded, or holds something
+             * that is not a reference), fall through to the comparison below.
+             */
+            if (columnType === TableColumnType.EntityArray ||
+                columnType === TableColumnType.Entity) {
+                const sameRelationIds = RelationValueUtil.haveSameRelationIds(currentValue, updatedValue);
+                if (sameRelationIds === false) {
+                    return false;
+                }
+                if (sameRelationIds === true) {
+                    continue;
+                }
+            }
             /*
              * Plain JSON objects all stringify through Object.toString as
              * "[object Object]". Compare their contents instead, while ignoring
@@ -2270,6 +2446,7 @@ class DatabaseService extends BaseService {
                 _id: updateById.id.toString(),
             },
             data: updateById.data,
+            miscDataProps: updateById.miscDataProps,
             props: updateById.props,
         });
     }