typeorm 0.3.29 → 0.3.31

package/browser/driver/types/InvalidFindOptionsWhereBehavior.d.ts

@@ -0,0 +1,15 @@
+export type InvalidFindOptionsWhereBehavior = {
+    /**
+     * How to handle null values in where conditions.
+     * - 'ignore': Skip null properties (default)
+     * - 'sql-null': Transform null to SQL NULL
+     * - 'throw': Throw an error when null is encountered
+     */
+    readonly null?: "ignore" | "sql-null" | "throw";
+    /**
+     * How to handle undefined values in where conditions.
+     * - 'ignore': Skip undefined properties (default)
+     * - 'throw': Throw an error when undefined is encountered
+     */
+    readonly undefined?: "ignore" | "throw";
+};

package/browser/driver/types/InvalidFindOptionsWhereBehavior.js

@@ -0,0 +1,3 @@
+export {};
+
+//# sourceMappingURL=InvalidFindOptionsWhereBehavior.js.map

package/browser/driver/types/InvalidFindOptionsWhereBehavior.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../browser/src/driver/types/InvalidFindOptionsWhereBehavior.ts"],"names":[],"mappings":"","file":"InvalidFindOptionsWhereBehavior.js","sourcesContent":["export type InvalidFindOptionsWhereBehavior = {\n    /**\n     * How to handle null values in where conditions.\n     * - 'ignore': Skip null properties (default)\n     * - 'sql-null': Transform null to SQL NULL\n     * - 'throw': Throw an error when null is encountered\n     */\n    readonly null?: \"ignore\" | \"sql-null\" | \"throw\"\n\n    /**\n     * How to handle undefined values in where conditions.\n     * - 'ignore': Skip undefined properties (default)\n     * - 'throw': Throw an error when undefined is encountered\n     */\n    readonly undefined?: \"ignore\" | \"throw\"\n}\n"],"sourceRoot":"../.."}

package/browser/entity-manager/EntityManager.d.ts

@@ -212,6 +212,23 @@ export declare class EntityManager {
      */
     insert<Entity extends ObjectLiteral>(target: EntityTarget<Entity>, entity: QueryDeepPartialEntity<Entity> | QueryDeepPartialEntity<Entity>[]): Promise<InsertResult>;
     upsert<Entity extends ObjectLiteral>(target: EntityTarget<Entity>, entityOrEntities: QueryDeepPartialEntity<Entity> | QueryDeepPartialEntity<Entity>[], conflictPathsOrOptions: string[] | UpsertOptions<Entity>): Promise<InsertResult>;
+    /**
+     * Shared by update/delete/softDelete/restore. Object criteria is normalized
+     * via {@link OrmUtils.normalizeWhereCriteria}, then rejected if it would
+     * produce no predicate and therefore render as an always-true `WHERE 1=1` —
+     * an empty object or array, an empty OR-branch, a bare primitive inside an
+     * OR-array, or a keyless object. Primitive id criteria is returned untouched
+     * for `whereInIds` (rejected only when wholly empty).
+     *
+     * @param criteria the raw criteria passed to the operation
+     * @param methodName the calling method, used in the error message
+     * @returns the criteria to build with, and whether to execute it via
+     *   `whereInIds` (primitive) or `where` (object)
+     */
+    protected normalizeAndValidateWhereCriteria(criteria: any, methodName: string): {
+        criteria: any;
+        isPrimitive: boolean;
+    };
     /**
      * Updates entity partially. Entity can be found by a given condition(s).
      * Unlike save method executes a primitive operation without cascades, relations and other operations included.
@@ -372,6 +389,12 @@ export declare class EntityManager {
      * Decrements some column by provided value of the entities matched given conditions.
      */
     decrement<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, conditions: any, propertyPath: string, value: number | string): Promise<UpdateResult>;
+    /**
+     * Shared implementation of {@link increment} and {@link decrement}: builds a
+     * `column = column +/- value` UPDATE and delegates execution to {@link update},
+     * so the criteria handling stays aligned with the other write methods.
+     */
+    protected incrementOrDecrementBy<Entity extends ObjectLiteral>(operation: "increment" | "decrement", entityClass: EntityTarget<Entity>, conditions: any, propertyPath: string, value: number | string): Promise<UpdateResult>;
     /**
      * Gets repository for the given entity class or name.
      * If single database connection mode is used, then repository is obtained from the

package/browser/entity-manager/EntityManager.js

@@ -336,6 +336,51 @@ export class EntityManager {
         }
         return qb.execute();
     }
+    /**
+     * Shared by update/delete/softDelete/restore. Object criteria is normalized
+     * via {@link OrmUtils.normalizeWhereCriteria}, then rejected if it would
+     * produce no predicate and therefore render as an always-true `WHERE 1=1` —
+     * an empty object or array, an empty OR-branch, a bare primitive inside an
+     * OR-array, or a keyless object. Primitive id criteria is returned untouched
+     * for `whereInIds` (rejected only when wholly empty).
+     *
+     * @param criteria the raw criteria passed to the operation
+     * @param methodName the calling method, used in the error message
+     * @returns the criteria to build with, and whether to execute it via
+     *   `whereInIds` (primitive) or `where` (object)
+     */
+    normalizeAndValidateWhereCriteria(criteria, methodName) {
+        const rejectEmpty = () => {
+            throw new TypeORMError(`Empty criteria(s) are not allowed for the ${methodName} method.`);
+        };
+        if (OrmUtils.isPrimitiveCriteria(criteria)) {
+            if (OrmUtils.isCriteriaNullOrEmpty(criteria))
+                rejectEmpty();
+            return { criteria, isPrimitive: true };
+        }
+        const normalizedCriteria = OrmUtils.normalizeWhereCriteria(criteria, this.connection.options.invalidWhereValuesBehavior);
+        // On the object-criteria path, `.where()` builds a predicate only from
+        // an object's own keys. Anything else yields an empty predicate list
+        // that renders as an always-true `1=1`, so a criterion is unsafe unless
+        // it is a non-empty object. This must reject:
+        //  - primitives (a bare number/string in a mixed OR-array like
+        //    `[1, { id: 2 }]` — `.where(1)` produces no predicate),
+        //  - empty plain objects (`{}`), empty arrays (`[]`), and
+        //  - empty non-plain objects, e.g. an empty entity instance
+        //    (`new Post()`), which isCriteriaNullOrEmpty does not catch.
+        // Value-type criteria (Date, Buffer) execute via the primitive branch
+        // and never reach here.
+        const rendersNoPredicate = (value) => value === null ||
+            typeof value !== "object" ||
+            Object.keys(value).length === 0;
+        const isEmpty = Array.isArray(normalizedCriteria)
+            ? normalizedCriteria.length === 0 ||
+                normalizedCriteria.some(rendersNoPredicate)
+            : rendersNoPredicate(normalizedCriteria);
+        if (isEmpty)
+            rejectEmpty();
+        return { criteria: normalizedCriteria, isPrimitive: false };
+    }
     /**
      * Updates entity partially. Entity can be found by a given condition(s).
      * Unlike save method executes a primitive operation without cascades, relations and other operations included.
@@ -343,31 +388,19 @@ export class EntityManager {
      * Does not check if entity exist in the database.
      * Condition(s) cannot be empty.
      */
-    update(target, criteria, partialEntity, options) {
-        // if user passed empty criteria or empty list of criterias, then throw an error
-        if (OrmUtils.isCriteriaNullOrEmpty(criteria)) {
-            return Promise.reject(new TypeORMError(`Empty criteria(s) are not allowed for the update method.`));
-        }
-        if (OrmUtils.isPrimitiveCriteria(criteria)) {
-            const qb = this.createQueryBuilder()
-                .update(target)
-                .set(partialEntity)
-                .whereInIds(criteria);
-            if (options?.returning !== undefined) {
-                qb.returning(options.returning);
-            }
-            return qb.execute();
+    async update(target, criteria, partialEntity, options) {
+        const { criteria: whereCriteria, isPrimitive } = this.normalizeAndValidateWhereCriteria(criteria, "update");
+        const qb = this.createQueryBuilder().update(target).set(partialEntity);
+        if (isPrimitive) {
+            qb.whereInIds(whereCriteria);
         }
         else {
-            const qb = this.createQueryBuilder()
-                .update(target)
-                .set(partialEntity)
-                .where(criteria);
-            if (options?.returning !== undefined) {
-                qb.returning(options.returning);
-            }
-            return qb.execute();
+            qb.where(whereCriteria);
+        }
+        if (options?.returning !== undefined) {
+            qb.returning(options.returning);
         }
+        return qb.execute();
     }
     /**
      * Updates all entities of target type, setting fields from supplied partial entity.
@@ -390,25 +423,10 @@ export class EntityManager {
      * Does not check if entity exist in the database.
      * Condition(s) cannot be empty.
      */
-    delete(targetOrEntity, criteria) {
-        // if user passed empty criteria or empty list of criterias, then throw an error
-        if (OrmUtils.isCriteriaNullOrEmpty(criteria)) {
-            return Promise.reject(new TypeORMError(`Empty criteria(s) are not allowed for the delete method.`));
-        }
-        if (OrmUtils.isPrimitiveCriteria(criteria)) {
-            return this.createQueryBuilder()
-                .delete()
-                .from(targetOrEntity)
-                .whereInIds(criteria)
-                .execute();
-        }
-        else {
-            return this.createQueryBuilder()
-                .delete()
-                .from(targetOrEntity)
-                .where(criteria)
-                .execute();
-        }
+    async delete(targetOrEntity, criteria) {
+        const { criteria: whereCriteria, isPrimitive } = this.normalizeAndValidateWhereCriteria(criteria, "delete");
+        const qb = this.createQueryBuilder().delete().from(targetOrEntity);
+        return (isPrimitive ? qb.whereInIds(whereCriteria) : qb.where(whereCriteria)).execute();
     }
     /**
      * Deletes all entities of target type.
@@ -427,25 +445,10 @@ export class EntityManager {
      * Does not check if entity exist in the database.
      * Condition(s) cannot be empty.
      */
-    softDelete(targetOrEntity, criteria) {
-        // if user passed empty criteria or empty list of criterias, then throw an error
-        if (OrmUtils.isCriteriaNullOrEmpty(criteria)) {
-            return Promise.reject(new TypeORMError(`Empty criteria(s) are not allowed for the softDelete method.`));
-        }
-        if (OrmUtils.isPrimitiveCriteria(criteria)) {
-            return this.createQueryBuilder()
-                .softDelete()
-                .from(targetOrEntity)
-                .whereInIds(criteria)
-                .execute();
-        }
-        else {
-            return this.createQueryBuilder()
-                .softDelete()
-                .from(targetOrEntity)
-                .where(criteria)
-                .execute();
-        }
+    async softDelete(targetOrEntity, criteria) {
+        const { criteria: whereCriteria, isPrimitive } = this.normalizeAndValidateWhereCriteria(criteria, "softDelete");
+        const qb = this.createQueryBuilder().softDelete().from(targetOrEntity);
+        return (isPrimitive ? qb.whereInIds(whereCriteria) : qb.where(whereCriteria)).execute();
     }
     /**
      * Restores entities by a given condition(s).
@@ -454,25 +457,10 @@ export class EntityManager {
      * Does not check if entity exist in the database.
      * Condition(s) cannot be empty.
      */
-    restore(targetOrEntity, criteria) {
-        // if user passed empty criteria or empty list of criterias, then throw an error
-        if (OrmUtils.isCriteriaNullOrEmpty(criteria)) {
-            return Promise.reject(new TypeORMError(`Empty criteria(s) are not allowed for the restore method.`));
-        }
-        if (OrmUtils.isPrimitiveCriteria(criteria)) {
-            return this.createQueryBuilder()
-                .restore()
-                .from(targetOrEntity)
-                .whereInIds(criteria)
-                .execute();
-        }
-        else {
-            return this.createQueryBuilder()
-                .restore()
-                .from(targetOrEntity)
-                .where(criteria)
-                .execute();
-        }
+    async restore(targetOrEntity, criteria) {
+        const { criteria: whereCriteria, isPrimitive } = this.normalizeAndValidateWhereCriteria(criteria, "restore");
+        const qb = this.createQueryBuilder().restore().from(targetOrEntity);
+        return (isPrimitive ? qb.whereInIds(whereCriteria) : qb.where(whereCriteria)).execute();
     }
     /**
      * Checks whether any entity exists with the given options.
@@ -714,45 +702,34 @@ export class EntityManager {
      * Increments some column by provided value of the entities matched given conditions.
      */
     async increment(entityClass, conditions, propertyPath, value) {
-        const metadata = this.connection.getMetadata(entityClass);
-        const column = metadata.findColumnWithPropertyPath(propertyPath);
-        if (!column)
-            throw new TypeORMError(`Column ${propertyPath} was not found in ${metadata.targetName} entity.`);
-        if (isNaN(Number(value)))
-            throw new TypeORMError(`Value "${value}" is not a number.`);
-        // convert possible embedded path "social.likes" into object { social: { like: () => value } }
-        const values = propertyPath
-            .split(".")
-            .reduceRight((value, key) => ({ [key]: value }), () => this.connection.driver.escape(column.databaseName) +
-            " + " +
-            value);
-        return this.createQueryBuilder(entityClass, "entity")
-            .update(entityClass)
-            .set(values)
-            .where(conditions)
-            .execute();
+        return this.incrementOrDecrementBy("increment", entityClass, conditions, propertyPath, value);
     }
     /**
      * Decrements some column by provided value of the entities matched given conditions.
      */
     async decrement(entityClass, conditions, propertyPath, value) {
+        return this.incrementOrDecrementBy("decrement", entityClass, conditions, propertyPath, value);
+    }
+    /**
+     * Shared implementation of {@link increment} and {@link decrement}: builds a
+     * `column = column +/- value` UPDATE and delegates execution to {@link update},
+     * so the criteria handling stays aligned with the other write methods.
+     */
+    incrementOrDecrementBy(operation, entityClass, conditions, propertyPath, value) {
         const metadata = this.connection.getMetadata(entityClass);
         const column = metadata.findColumnWithPropertyPath(propertyPath);
         if (!column)
             throw new TypeORMError(`Column ${propertyPath} was not found in ${metadata.targetName} entity.`);
         if (isNaN(Number(value)))
             throw new TypeORMError(`Value "${value}" is not a number.`);
+        const operator = operation === "increment" ? "+" : "-";
         // convert possible embedded path "social.likes" into object { social: { like: () => value } }
         const values = propertyPath
             .split(".")
             .reduceRight((value, key) => ({ [key]: value }), () => this.connection.driver.escape(column.databaseName) +
-            " - " +
+            ` ${operator} ` +
             value);
-        return this.createQueryBuilder(entityClass, "entity")
-            .update(entityClass)
-            .set(values)
-            .where(conditions)
-            .execute();
+        return this.update(entityClass, conditions, values);
     }
     /**
      * Gets repository for the given entity class or name.