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

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;

package/dist/spanner/conversion.js

@@ -7,38 +7,23 @@ import { getSpannerColumnsMetadata, } from './column.decorator.js';
  *
  * @param spannerObject The object returned by Spanner that should be converted back to a class instance.
  * @param type The class for the object.
- * @param options Used for recursion and should not be set directly.
  * @returns The created object.
  */
-function spannerObjectToInstanceWithOptions(spannerObject, type, options = {}) {
+export function spannerObjectToInstance(spannerObject, type) {
     const columnsMetadata = getSpannerColumnsMetadata(type);
-    const columnNamePrefix = options.columnNamePrefix ?? '';
-    const plain = {};
-    let hasAtLeastOneNonNullValue = false;
-    Object.entries(columnsMetadata).forEach(([property, columnMetadata]) => {
-        const columnName = `${columnNamePrefix}${columnMetadata.name}`;
-        if (columnMetadata.nestedType) {
-            plain[property] = spannerObjectToInstanceWithOptions(spannerObject, columnMetadata.nestedType, {
-                columnNamePrefix: `${columnName}_`,
-                nullifyInstance: columnMetadata.nullifyNested,
-            });
-        }
-        else if (columnMetadata.isJson) {
-            plain[property] = spannerObject[columnName];
-        }
-        else if (Array.isArray(spannerObject[columnName])) {
-            plain[property] = spannerObject[columnName].map((v) => spannerValueToJavaScript(v, columnMetadata));
-        }
-        else {
-            plain[property] = spannerValueToJavaScript(spannerObject[columnName], columnMetadata);
-        }
-        if (plain[property] != null) {
-            hasAtLeastOneNonNullValue = true;
-        }
-    });
-    return hasAtLeastOneNonNullValue || !options.nullifyInstance
-        ? plainToInstance(type, plain)
-        : null;
+    const plain = Object.fromEntries(Object.entries(columnsMetadata).map(([property, columnMetadata]) => {
+        const columnName = columnMetadata.name;
+        const value = spannerObject[columnName];
+        if (columnMetadata.isJson) {
+            return [property, value];
+        }
+        if (Array.isArray(value)) {
+            const values = value.map((v) => spannerValueToJavaScript(v, columnMetadata));
+            return [property, values];
+        }
+        return [property, spannerValueToJavaScript(value, columnMetadata)];
+    }));
+    return plainToInstance(type, plain);
 }
 /**
  * Converts a scalar value returned by Spanner to a regular JavaScript value.
@@ -54,17 +39,15 @@ function spannerValueToJavaScript(value, columnMetadata) {
         // Floats are always safe and can always be unwrapped.
         return value.valueOf();
     }
-    else if (value instanceof Int) {
+    if (value instanceof Int) {
         if (columnMetadata.isBigInt) {
             return BigInt(value.value);
         }
-        else {
-            // This unwraps the string to an integer number, but might throw if the integer is above what can be represented
-            // safely as a float.
-            return value.valueOf();
-        }
+        // This unwraps the string to an integer number, but might throw if the integer is above what can be represented
+        // safely as a float.
+        return value.valueOf();
     }
-    else if (value instanceof Date &&
+    if (value instanceof Date &&
         // `PreciseDate` extends `Date`. This was previously used to handle conflicting versions of `PreciseDate`.
         value.constructor.name === PreciseDate.name &&
         !columnMetadata.isPreciseDate) {
@@ -74,17 +57,6 @@ function spannerValueToJavaScript(value, columnMetadata) {
     }
     return value;
 }
-/**
- * Creates a typed class instance from an object returned by the Spanner API.
- *
- * @param spannerObject The object returned by Spanner that should be converted back to a class instance.
- * @param type The class for the object.
- * @returns The created object.
- */
-export function spannerObjectToInstance(spannerObject, type) {
-    // This is okay as `null` can only be returned when the internal option `nullifyInstance` is set.
-    return spannerObjectToInstanceWithOptions(spannerObject, type);
-}
 /**
  * Converts a value such that it is safe to pass to the Spanner client.
  * Numeric values and arrays of numeric values are wrapped using Spanner classes.
@@ -103,50 +75,19 @@ function makeSpannerValue(value, metadata) {
             ? value.map((v) => new Int(v.toString()))
             : new Int(value.toString());
     }
-    else if (metadata.isJson) {
+    if (metadata.isJson) {
         return JSON.stringify(value);
     }
-    else if (typeof value === 'number') {
+    if (typeof value === 'number') {
         return new Float(value);
     }
-    else if (Array.isArray(value) &&
+    if (Array.isArray(value) &&
         value.length > 0 &&
         typeof value[0] === 'number') {
         return value.map((v) => new Float(v));
     }
     return value;
 }
-/**
- * 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.
- * @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 function instanceToSpannerObjectInternal(instance, type, columnNamePrefix = '') {
-    const columnsMetadata = getSpannerColumnsMetadata(type);
-    let spannerObject = {};
-    Object.entries(columnsMetadata).forEach(([property, columnMetadata]) => {
-        const columnName = `${columnNamePrefix}${columnMetadata.name}`;
-        // When the current property value is `undefined`, column(s) values should not be set.
-        if (instance !== null && instance[property] === undefined) {
-            return;
-        }
-        // When the whole instance is `null`, all its child properties should be set to null.
-        const propertyValue = instance === null ? null : instance[property];
-        if (columnMetadata.nestedType) {
-            spannerObject = {
-                ...spannerObject,
-                ...instanceToSpannerObjectInternal(propertyValue, columnMetadata.nestedType, `${columnName}_`),
-            };
-        }
-        else {
-            spannerObject[columnName] = makeSpannerValue(propertyValue, columnMetadata);
-        }
-    });
-    return spannerObject;
-}
 /**
  * Converts a class object to a plain JavaScript object that can be passed to the Spanner API.
  *
@@ -155,11 +96,18 @@ export function instanceToSpannerObjectInternal(instance, type, columnNamePrefix
  * @returns A generic JavaScript object that can be passed to the Spanner API.
  */
 export function instanceToSpannerObject(instance, type) {
-    return instanceToSpannerObjectInternal(instance, type);
+    const columnsMetadata = getSpannerColumnsMetadata(type);
+    return Object.fromEntries(Object.entries(columnsMetadata)
+        .map(([p, m]) => [m, instance[p]])
+        // When the current property value is `undefined`, the column value should not be set.
+        .filter(([, v]) => v !== undefined)
+        .map(([metadata, value]) => [
+        metadata.name,
+        makeSpannerValue(value, metadata),
+    ]));
 }
 /**
- * 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.
@@ -167,30 +115,14 @@ export function instanceToSpannerObject(instance, type) {
  */
 export function copyInstanceWithMissingColumnsToNull(instance, type) {
     const columnsMetadata = getSpannerColumnsMetadata(type);
-    const plain = {};
-    Object.entries(columnsMetadata).forEach(([property, columnMetadata]) => {
-        const instanceValue = instance == null ? null : instance[property];
-        if (columnMetadata.nestedType) {
-            if (columnMetadata.nullifyNested && instanceValue == null) {
-                plain[property] = null;
-            }
-            else {
-                plain[property] = copyInstanceWithMissingColumnsToNull(instanceValue, columnMetadata.nestedType);
-            }
-        }
-        else if (instanceValue !== undefined) {
-            plain[property] = instanceValue;
-        }
-        else {
-            plain[property] = null;
-        }
-    });
+    const plain = Object.fromEntries(Object.keys(columnsMetadata).map((property) => {
+        const value = instance[property];
+        return [property, value === undefined ? null : value];
+    }));
     return plainToInstance(type, plain);
 }
 /**
- * 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.
@@ -200,25 +132,13 @@ export function copyInstanceWithMissingColumnsToNull(instance, type) {
 export function updateInstanceByColumn(instance, update, type) {
     type ??= instance.constructor;
     const columnsMetadata = getSpannerColumnsMetadata(type);
-    const plain = {};
-    Object.entries(columnsMetadata).forEach(([property, columnMetadata]) => {
-        const instanceValue = instance == null ? null : instance[property];
-        const updateValue = update == null ? update : update[property];
-        if (updateValue === undefined) {
-            plain[property] = instanceValue;
-            return;
-        }
-        if (columnMetadata.nestedType) {
-            if (columnMetadata.nullifyNested && updateValue === null) {
-                plain[property] = null;
-            }
-            else {
-                plain[property] = updateInstanceByColumn(instanceValue, updateValue, columnMetadata.nestedType);
-            }
-        }
-        else if (updateValue !== undefined) {
-            plain[property] = updateValue;
-        }
-    });
+    const plain = Object.fromEntries(Object.keys(columnsMetadata).map((property) => {
+        const instanceValue = instance[property];
+        const updateValue = update[property];
+        return [
+            property,
+            updateValue === undefined ? instanceValue : updateValue,
+        ];
+    }));
     return plainToInstance(type, plain);
 }