@causa/runtime-google 0.39.1 → 1.0.0-rc.1

package/dist/pubsub/{testing/fixture.d.ts → testing.d.ts}

@@ -1,7 +1,7 @@
 import { type ObjectSerializer } from '@causa/runtime';
-import type { NestJsModuleOverrider } from '@causa/runtime/nestjs/testing';
+import type { AppFixture, EventFixture, Fixture, NestJsModuleOverrider } from '@causa/runtime/nestjs/testing';
 import { PubSub, Subscription, Topic } from '@google-cloud/pubsub';
-import type { Type } from '@nestjs/common';
+import { type Type } from '@nestjs/common';
 /**
  * A received Pub/Sub message that was deserialized.
  */
@@ -20,27 +20,51 @@ export type ReceivedPubSubEvent = {
     event: any;
 };
 /**
- * Options for the {@link PubSubFixture.expectMessageInTopic} method.
+ * Options for the {@link PubSubFixture.expectMessage} method.
  */
-type ExpectMessageInTopicOptions = {
+export type ExpectMessageOptions = {
     /**
      * The maximum time (in milliseconds) to wait for a message before giving up.
      * Defaults to `2000`.
      */
     timeout?: number;
 };
+/**
+ * Options when making a request to an endpoint handling Pub/Sub events using an {@link EventRequester}.
+ */
+export type EventRequesterOptions = {
+    /**
+     * The attributes to add to the Pub/Sub message.
+     * Using `undefined` values allows removing the attributes set by default.
+     */
+    attributes?: Record<string, string | undefined>;
+    /**
+     * The expected status code when making the request.
+     * Default is `200`.
+     */
+    expectedStatus?: number;
+    /**
+     * The time to set as the publication time of the Pub/Sub message.
+     */
+    publishTime?: Date;
+};
+/**
+ * A function that makes a query to an endpoint handling Pub/Sub events and tests the response.
+ */
+export type EventRequester = (event: object, options?: EventRequesterOptions) => Promise<void>;
 /**
  * A utility class managing temporary Pub/Sub topics and listening to messages published to them.
  */
-export declare class PubSubFixture {
+export declare class PubSubFixture implements Fixture, EventFixture {
+    private readonly topicsAndTypes;
     /**
-     * The Pub/Sub client to use.
+     * The parent {@link AppFixture}.
      */
-    readonly pubSub: PubSub;
+    private appFixture;
     /**
-     * Whether the Pub/Sub client is managed by the fixture.
+     * The Pub/Sub client to use.
      */
-    private readonly isManagedClient;
+    readonly pubSub: PubSub;
     /**
      * The (de)serializer to use for Pub/Sub messages.
      */
@@ -49,7 +73,7 @@ export declare class PubSubFixture {
      * The dictionary of monitored temporary topics.
      * The key is the name of the event topic (not broker-specific).
      */
-    readonly fixtures: Record<string, {
+    readonly topics: Record<string, {
         /**
          * The created temporary Pub/Sub topic.
          */
@@ -66,13 +90,10 @@ export declare class PubSubFixture {
     /**
      * Creates a new {@link PubSubFixture}.
      *
+     * @param topicsAndTypes The dictionary of topics to test and their event types.
      * @param options Options for the fixture.
      */
-    constructor(options?: {
-        /**
-         * The Pub/Sub client to use.
-         */
-        pubSub?: PubSub;
+    constructor(topicsAndTypes: Record<string, Type>, options?: {
         /**
          * The (de)serializer to use for Pub/Sub messages.
          */
@@ -81,44 +102,46 @@ export declare class PubSubFixture {
     /**
      * Creates a new temporary topic and starts listening to messages published to it.
      *
-     * @param sourceTopicName The original name of the topic, i.e. the one used in production.
+     * @param sourceTopic The original name of the topic, i.e. the one used in production.
      * @param eventType The type of the event published to the topic, used for deserialization.
      * @returns The configuration key and value for the created temporary topic.
      */
-    create(sourceTopicName: string, eventType: Type): Promise<Record<string, string>>;
-    /**
-     * Creates several temporary topics and returns the configuration (environment variables) for the
-     *
-     * @param topicsAndTypes A dictionary of topics and their corresponding event types.
-     * @returns The configuration for Pub/Sub topics, with the IDs of the created topics.
-     */
-    createMany(topicsAndTypes: Record<string, Type>): Promise<Record<string, string>>;
+    private create;
+    init(appFixture: AppFixture): Promise<NestJsModuleOverrider>;
     /**
-     * Uses {@link PubSubFixture.createMany} to create temporary topics and returns a {@link NestJsModuleOverrider} to
-     * override the Pub/Sub publisher configuration.
+     * Creates an {@link EventRequester} for an endpoint handling Pub/Sub messages.
+     * If the `event` passed to the {@link EventRequester} conforms to the `Event` interface (if it has `producedAt`,
+     * `name` and / or `id` properties), the default attributes are set in the Pub/Sub message. Default attributes can be
+     * overridden (or removed by passing `undefined`) using {@link EventRequesterOptions.attributes}.
      *
-     * @param topicsAndTypes A dictionary of topics and their corresponding event types.
-     * @returns The {@link NestJsModuleOverrider} to use to override the Pub/Sub publisher configuration.
+     * @param endpoint The endpoint to query.
+     * @param options Options when creating the requester.
+     * @returns The {@link EventRequester}.
      */
-    createWithOverrider(topicsAndTypes: Record<string, Type>): Promise<NestJsModuleOverrider>;
+    makeRequester(endpoint: string, options?: {
+        /**
+         * The default expected status code when making a request.
+         */
+        expectedStatus?: number;
+    }): EventRequester;
     /**
      * Checks that the given message has been published to the specified topic.
      *
-     * @param sourceTopicName The original name of the event topic.
+     * @param topic The original name of the event topic.
      * @param expectedMessage The message expected to have been published.
      *   This can be an `expect` expression, e.g. `expect.objectContaining({})`.
      * @param options Options for the expectation.
      */
-    expectMessageInTopic(sourceTopicName: string, expectedMessage: any, options?: ExpectMessageInTopicOptions): Promise<void>;
+    expectMessage(topic: string, expectedMessage: any, options?: ExpectMessageOptions): Promise<void>;
     /**
-     * Uses {@link PubSubFixture.expectMessageInTopic} to check that the given event has been published to the specified
+     * Uses {@link PubSubFixture.expectMessage} to check that the given event has been published to the specified
      * topic. The `expectedEvent` is the payload of the message, i.e. the `event` property.
      *
-     * @param sourceTopicName The original name of the event topic.
+     * @param topic The original name of the event topic.
      * @param expectedEvent The event expected to have been published.
      * @param options Options for the expectation.
      */
-    expectEventInTopic(sourceTopicName: string, expectedEvent: any, options?: ExpectMessageInTopicOptions & {
+    expectEvent(topic: string, expectedEvent: any, options?: ExpectMessageOptions & {
         /**
          * The attributes expected to have been published with the event.
          * This may contain only a subset of the attributes.
@@ -130,29 +153,22 @@ export declare class PubSubFixture {
      * By default, because publishing (and receiving) the messages is asynchronous, a small delay is added before checking
      * that no message has been received. This delay can be removed or increased by passing the `delay` option.
      *
-     * @param sourceTopicName The original name of the topic, i.e. the one used in production.
+     * @param topic The original name of the topic, i.e. the one used in production.
      * @param options Options for the expectation.
      */
-    expectNoMessageInTopic(sourceTopicName: string, options?: {
+    expectNoMessage(topic: string, options?: {
         /**
          * The delay (in milliseconds) before checking that no message has been received.
          */
         delay?: number;
     }): Promise<void>;
-    /**
-     * Clears all the messages received from the temporary topics.
-     */
-    clear(): void;
+    expectNoEvent(topic: string): Promise<void>;
+    clear(): Promise<void>;
     /**
      * Deletes the temporary topic for the corresponding "production" topic.
      *
-     * @param sourceTopicName The original name of the topic, i.e. the one used in production.
-     */
-    delete(sourceTopicName: string): Promise<void>;
-    /**
-     * Deletes all previously created temporary topics.
-     * If the Pub/Sub client was managed by the fixture (it wasn't passed as an option), it is also closed.
+     * @param topic The original name of the topic, i.e. the one used in production.
      */
-    deleteAll(): Promise<void>;
+    deleteTopic(topic: string): Promise<void>;
+    delete(): Promise<void>;
 }
-export {};

package/dist/pubsub/{testing/fixture.js → testing.js}

@@ -1,9 +1,10 @@
 import { JsonObjectSerializer } from '@causa/runtime';
 import { Message, PubSub, Subscription, Topic } from '@google-cloud/pubsub';
+import { HttpStatus } from '@nestjs/common';
 import { setTimeout } from 'timers/promises';
 import * as uuid from 'uuid';
-import { getConfigurationKeyForTopic } from '../configuration.js';
-import { PUBSUB_PUBLISHER_CONFIGURATION_GETTER_INJECTION_NAME } from '../publisher.module.js';
+import { getConfigurationKeyForTopic } from './configuration.js';
+import { PUBSUB_PUBLISHER_CONFIGURATION_GETTER_INJECTION_NAME } from './publisher.module.js';
 /**
  * The default duration (in milliseconds) after which `expectMessageInTopic` times out.
  */
@@ -20,14 +21,15 @@ const DURATION_BETWEEN_EXPECT_ATTEMPTS = 50;
  * A utility class managing temporary Pub/Sub topics and listening to messages published to them.
  */
 export class PubSubFixture {
+    topicsAndTypes;
     /**
-     * The Pub/Sub client to use.
+     * The parent {@link AppFixture}.
      */
-    pubSub;
+    appFixture;
     /**
-     * Whether the Pub/Sub client is managed by the fixture.
+     * The Pub/Sub client to use.
      */
-    isManagedClient;
+    pubSub;
     /**
      * The (de)serializer to use for Pub/Sub messages.
      */
@@ -36,85 +38,122 @@ export class PubSubFixture {
      * The dictionary of monitored temporary topics.
      * The key is the name of the event topic (not broker-specific).
      */
-    fixtures = {};
+    topics = {};
     /**
      * Creates a new {@link PubSubFixture}.
      *
+     * @param topicsAndTypes The dictionary of topics to test and their event types.
      * @param options Options for the fixture.
      */
-    constructor(options = {}) {
-        this.pubSub = options.pubSub ?? new PubSub();
-        this.isManagedClient = !options.pubSub;
+    constructor(topicsAndTypes, options = {}) {
+        this.topicsAndTypes = topicsAndTypes;
+        this.pubSub = new PubSub();
         this.serializer = options.serializer ?? new JsonObjectSerializer();
     }
     /**
      * Creates a new temporary topic and starts listening to messages published to it.
      *
-     * @param sourceTopicName The original name of the topic, i.e. the one used in production.
+     * @param sourceTopic The original name of the topic, i.e. the one used in production.
      * @param eventType The type of the event published to the topic, used for deserialization.
      * @returns The configuration key and value for the created temporary topic.
      */
-    async create(sourceTopicName, eventType) {
-        await this.delete(sourceTopicName);
+    async create(sourceTopic, eventType) {
+        await this.deleteTopic(sourceTopic);
         const suffix = uuid.v4().slice(-10);
-        const topicName = `${sourceTopicName}-${suffix}`;
+        const topicName = `${sourceTopic}-${suffix}`;
         const subscriptionName = `fixture-${suffix}`;
         // This ensures the project ID is populated in the Pub/Sub client.
         // Because the configuration is cached, it should be okay to call this multiple times.
         await this.pubSub.getClientConfig();
         const [topic] = await this.pubSub.createTopic(topicName);
         const [subscription] = await topic.createSubscription(subscriptionName);
-        this.fixtures[sourceTopicName] = { topic, subscription, messages: [] };
+        this.topics[sourceTopic] = { topic, subscription, messages: [] };
         subscription.on('message', async (message) => {
-            const fixture = this.fixtures[sourceTopicName];
-            if (!fixture || fixture.topic !== topic) {
+            const topicFixture = this.topics[sourceTopic];
+            if (topicFixture?.topic !== topic) {
                 return;
             }
             const event = await this.serializer.deserialize(eventType, message.data);
-            fixture.messages.push({
+            topicFixture.messages.push({
                 attributes: message.attributes,
                 orderingKey: message.orderingKey ? message.orderingKey : undefined,
                 event,
             });
             message.ack();
         });
-        return { [getConfigurationKeyForTopic(sourceTopicName)]: topic.name };
+        return { [getConfigurationKeyForTopic(sourceTopic)]: topic.name };
     }
-    /**
-     * Creates several temporary topics and returns the configuration (environment variables) for the
-     *
-     * @param topicsAndTypes A dictionary of topics and their corresponding event types.
-     * @returns The configuration for Pub/Sub topics, with the IDs of the created topics.
-     */
-    async createMany(topicsAndTypes) {
-        const configurations = await Promise.all(Object.entries(topicsAndTypes).map(async ([topicName, eventType]) => this.create(topicName, eventType)));
-        return Object.assign({}, ...configurations);
+    async init(appFixture) {
+        this.appFixture = appFixture;
+        const configurations = await Promise.all(Object.entries(this.topicsAndTypes).map(([topic, eventType]) => this.create(topic, eventType)));
+        const configuration = Object.assign({}, ...configurations);
+        return (builder) => builder
+            .overrideProvider(PUBSUB_PUBLISHER_CONFIGURATION_GETTER_INJECTION_NAME)
+            .useValue((key) => configuration[key]);
     }
     /**
-     * Uses {@link PubSubFixture.createMany} to create temporary topics and returns a {@link NestJsModuleOverrider} to
-     * override the Pub/Sub publisher configuration.
+     * Creates an {@link EventRequester} for an endpoint handling Pub/Sub messages.
+     * If the `event` passed to the {@link EventRequester} conforms to the `Event` interface (if it has `producedAt`,
+     * `name` and / or `id` properties), the default attributes are set in the Pub/Sub message. Default attributes can be
+     * overridden (or removed by passing `undefined`) using {@link EventRequesterOptions.attributes}.
      *
-     * @param topicsAndTypes A dictionary of topics and their corresponding event types.
-     * @returns The {@link NestJsModuleOverrider} to use to override the Pub/Sub publisher configuration.
+     * @param endpoint The endpoint to query.
+     * @param options Options when creating the requester.
+     * @returns The {@link EventRequester}.
      */
-    async createWithOverrider(topicsAndTypes) {
-        const configuration = await this.createMany(topicsAndTypes);
-        return (builder) => builder
-            .overrideProvider(PUBSUB_PUBLISHER_CONFIGURATION_GETTER_INJECTION_NAME)
-            .useValue((key) => configuration[key]);
+    makeRequester(endpoint, options = {}) {
+        return async (event, requestOptions) => {
+            const messageId = uuid.v4();
+            const publishTime = (requestOptions?.publishTime ?? new Date()).toISOString();
+            const buffer = await this.serializer.serialize(event);
+            const data = buffer.toString('base64');
+            // Default attributes if the event conforms to the `Event` interface.
+            const defaultAttributes = {};
+            if ('producedAt' in event && event.producedAt instanceof Date) {
+                defaultAttributes.producedAt = event.producedAt.toISOString();
+            }
+            if ('name' in event && typeof event.name === 'string') {
+                defaultAttributes.eventName = event.name;
+            }
+            if ('id' in event && typeof event.id === 'string') {
+                defaultAttributes.eventId = event.id;
+            }
+            const attributes = {
+                ...defaultAttributes,
+                ...requestOptions?.attributes,
+            };
+            const payload = {
+                message: {
+                    messageId,
+                    message_id: messageId,
+                    publishTime,
+                    publish_time: publishTime,
+                    attributes,
+                    data,
+                },
+                subscription: 'subscription',
+            };
+            const expectedStatus = requestOptions?.expectedStatus ??
+                options.expectedStatus ??
+                HttpStatus.OK;
+            await this.appFixture.request
+                .post(endpoint)
+                .send(payload)
+                .expect(expectedStatus);
+        };
     }
     /**
      * Checks that the given message has been published to the specified topic.
      *
-     * @param sourceTopicName The original name of the event topic.
+     * @param topic The original name of the event topic.
      * @param expectedMessage The message expected to have been published.
      *   This can be an `expect` expression, e.g. `expect.objectContaining({})`.
      * @param options Options for the expectation.
      */
-    async expectMessageInTopic(sourceTopicName, expectedMessage, options = {}) {
-        const fixture = this.fixtures[sourceTopicName];
+    async expectMessage(topic, expectedMessage, options = {}) {
+        const fixture = this.topics[topic];
         if (!fixture) {
-            throw new Error(`Fixture for topic '${sourceTopicName}' does not exist.`);
+            throw new Error(`Fixture for topic '${topic}' does not exist.`);
         }
         const timeoutTime = new Date().getTime() + (options.timeout ?? DEFAULT_EXPECT_TIMEOUT);
         while (true) {
@@ -136,15 +175,15 @@ export class PubSubFixture {
         }
     }
     /**
-     * Uses {@link PubSubFixture.expectMessageInTopic} to check that the given event has been published to the specified
+     * Uses {@link PubSubFixture.expectMessage} to check that the given event has been published to the specified
      * topic. The `expectedEvent` is the payload of the message, i.e. the `event` property.
      *
-     * @param sourceTopicName The original name of the event topic.
+     * @param topic The original name of the event topic.
      * @param expectedEvent The event expected to have been published.
      * @param options Options for the expectation.
      */
-    async expectEventInTopic(sourceTopicName, expectedEvent, options = {}) {
-        await this.expectMessageInTopic(sourceTopicName, expect.objectContaining({
+    async expectEvent(topic, expectedEvent, options = {}) {
+        await this.expectMessage(topic, expect.objectContaining({
             event: expectedEvent,
             attributes: expect.objectContaining(options.attributes ?? {}),
         }), options);
@@ -154,13 +193,13 @@ export class PubSubFixture {
      * By default, because publishing (and receiving) the messages is asynchronous, a small delay is added before checking
      * that no message has been received. This delay can be removed or increased by passing the `delay` option.
      *
-     * @param sourceTopicName The original name of the topic, i.e. the one used in production.
+     * @param topic The original name of the topic, i.e. the one used in production.
      * @param options Options for the expectation.
      */
-    async expectNoMessageInTopic(sourceTopicName, options = {}) {
-        const fixture = this.fixtures[sourceTopicName];
+    async expectNoMessage(topic, options = {}) {
+        const fixture = this.topics[topic];
         if (!fixture) {
-            throw new Error(`Fixture for topic '${sourceTopicName}' does not exist.`);
+            throw new Error(`Fixture for topic '${topic}' does not exist.`);
         }
         const delay = options.delay ?? DEFAULT_EXPECT_NO_MESSAGE_DELAY;
         if (delay > 0) {
@@ -168,40 +207,34 @@ export class PubSubFixture {
         }
         const numMessages = fixture.messages.length;
         if (numMessages > 0) {
-            throw new Error(`Expected 0 messages in '${sourceTopicName}' but found ${numMessages}.`);
+            throw new Error(`Expected 0 messages in '${topic}' but found ${numMessages}.`);
         }
     }
-    /**
-     * Clears all the messages received from the temporary topics.
-     */
-    clear() {
-        Object.values(this.fixtures).forEach((f) => {
-            f.messages = [];
+    async expectNoEvent(topic) {
+        await this.expectNoMessage(topic);
+    }
+    async clear() {
+        Object.values(this.topics).forEach((t) => {
+            t.messages = [];
         });
     }
     /**
      * Deletes the temporary topic for the corresponding "production" topic.
      *
-     * @param sourceTopicName The original name of the topic, i.e. the one used in production.
+     * @param topic The original name of the topic, i.e. the one used in production.
      */
-    async delete(sourceTopicName) {
-        const fixture = this.fixtures[sourceTopicName];
-        if (!fixture) {
+    async deleteTopic(topic) {
+        const topicFixture = this.topics[topic];
+        if (!topicFixture) {
             return;
         }
-        delete this.fixtures[sourceTopicName];
-        fixture.subscription.removeAllListeners();
-        await fixture.subscription.delete();
-        await fixture.topic.delete();
+        delete this.topics[topic];
+        topicFixture.subscription.removeAllListeners();
+        await topicFixture.subscription.delete();
+        await topicFixture.topic.delete();
     }
-    /**
-     * Deletes all previously created temporary topics.
-     * If the Pub/Sub client was managed by the fixture (it wasn't passed as an option), it is also closed.
-     */
-    async deleteAll() {
-        await Promise.all(Object.keys(this.fixtures).map((sourceTopicName) => this.delete(sourceTopicName)));
-        if (this.isManagedClient) {
-            await this.pubSub.close();
-        }
+    async delete() {
+        await Promise.all(Object.keys(this.topics).map((t) => this.deleteTopic(t)));
+        await this.pubSub.close();
     }
 }

package/dist/spanner/column.decorator.d.ts

@@ -8,15 +8,6 @@ export type SpannerColumnMetadata = {
      * The name of the Spanner column for this property.
      */
     name: string;
-    /**
-     * If the type of the property is a nested type, this is the class for this property.
-     */
-    nestedType?: Type;
-    /**
-     * When `true`, sets the property to null if all properties is the nested object are null.
-     * Defaults to `false`.
-     */
-    nullifyNested: boolean;
     /**
      * When `true`, the column is assumed to be of type `INT64` and the value will be safely stored in a `bigint`.
      */
@@ -60,7 +51,6 @@ export declare function getSpannerColumnsMetadata(classType: Type): SpannerColum
  * Lists all the columns in the given class, based on {@link SpannerColumn} decorators.
  *
  * @param classType The type for the table.
- * @param namePrefix Used for recursion with nested types, do not use directly.
  * @returns The list of columns for the given class.
  */
-export declare function getSpannerColumns(classType: Type, namePrefix?: string): string[];
+export declare function getSpannerColumns(classType: Type): string[];

package/dist/spanner/column.decorator.js

@@ -16,8 +16,6 @@ export function SpannerColumn(options = {}) {
         const isPreciseDate = options.isPreciseDate ?? false;
         metadata[propertyKey] = {
             name: options.name ?? propertyKey,
-            nestedType: options.nestedType,
-            nullifyNested: options.nullifyNested ?? false,
             isInt: options.isInt ?? false,
             isBigInt: options.isBigInt ?? false,
             isPreciseDate,
@@ -55,12 +53,9 @@ export function getSpannerColumnsMetadata(classType) {
  * Lists all the columns in the given class, based on {@link SpannerColumn} decorators.
  *
  * @param classType The type for the table.
- * @param namePrefix Used for recursion with nested types, do not use directly.
  * @returns The list of columns for the given class.
  */
-export function getSpannerColumns(classType, namePrefix = '') {
+export function getSpannerColumns(classType) {
     const columnsMetadata = getSpannerColumnsMetadata(classType);
-    return Object.values(columnsMetadata).flatMap((c) => c.nestedType
-        ? getSpannerColumns(c.nestedType, `${c.name}_`)
-        : `${namePrefix}${c.name}`);
+    return Object.values(columnsMetadata).flatMap((c) => c.name);
 }

package/dist/spanner/conversion.d.ts

@@ -1,5 +1,4 @@
 import type { Type } from '@nestjs/common';
-import type { RecursivePartialEntity } from './types.js';
 /**
  * Creates a typed class instance from an object returned by the Spanner API.
  *
@@ -13,35 +12,23 @@ export declare function spannerObjectToInstance<T>(spannerObject: Record<string,
  *
  * @param instance The object to convert to a Spanner object.
  * @param type The type of the object to convert.
- * @param columnNamePrefix The prefix to add to column names. Used for recursion and should not be set directly.
  * @returns A generic JavaScript object that can be passed to the Spanner API.
  */
-export declare function instanceToSpannerObjectInternal<T>(instance: T | RecursivePartialEntity<T> | null, type: Type<T>, columnNamePrefix?: string): Record<string, any>;
+export declare function instanceToSpannerObject<T>(instance: T | Partial<T>, type: Type<T>): Record<string, any>;
 /**
- * Converts a class object to a plain JavaScript object that can be passed to the Spanner API.
- *
- * @param instance The object to convert to a Spanner object.
- * @param type The type of the object to convert.
- * @returns A generic JavaScript object that can be passed to the Spanner API.
- */
-export declare function instanceToSpannerObject<T>(instance: T | RecursivePartialEntity<T>, type: Type<T>): Record<string, any>;
-/**
- * Copies an instance, recursively setting all columns that are not defined in the instance to `null`.
- * Columns with the {@link SpannerColumnMetadata.nullifyNested} option set to `true` are also set to `null`.
+ * Copies an instance, setting all columns that are not defined in the instance to `null`.
  *
  * @param instance The instance to copy.
  * @param type The type of the instance.
  * @returns The copied instance.
  */
-export declare function copyInstanceWithMissingColumnsToNull<T>(instance: T | RecursivePartialEntity<T>, type: Type<T>): T;
+export declare function copyInstanceWithMissingColumnsToNull<T>(instance: T | Partial<T>, type: Type<T>): T;
 /**
- * Recursively updates an instance with the values from the update.
- * Updates are applied "column-wise", which means that recursion stops at properties decorated as columns.
- * For example, JSON values are not affected.
+ * Updates an instance with the values from the update.
  *
  * @param instance The instance to update. It should be a full, typed, instance, unless `type` is passed as well.
  * @param update The update to apply to the instance.
  * @param type The type of the instance. If not provided, it will be inferred from the instance.
  * @returns The updated instance.
  */
-export declare function updateInstanceByColumn<T>(instance: T, update: RecursivePartialEntity<T>, type?: Type<T>): T;
+export declare function updateInstanceByColumn<T>(instance: T, update: Partial<T>, type?: Type<T>): T;