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

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);
 }

package/dist/spanner/entity-manager.d.ts

@@ -3,7 +3,7 @@ import { type Type as ParamType } from '@google-cloud/spanner/build/src/codec.js
 import type { TimestampBounds } from '@google-cloud/spanner/build/src/transaction.js';
 import { type Type } from '@nestjs/common';
 import { SpannerTableCache } from './table-cache.js';
-import type { RecursivePartialEntity, SpannerReadOnlyTransactionOption, SpannerReadWriteTransactionOption } from './types.js';
+import type { SpannerReadOnlyTransactionOption, SpannerReadWriteTransactionOption } from './types.js';
 /**
  * Any Spanner transaction that can be used for reading.
  */
@@ -19,7 +19,7 @@ export type SpannerKey = (string | null)[];
 /**
  * Options for {@link SpannerEntityManager.snapshot}.
  */
-type SnapshotOptions = {
+type SnapshotOptions = SpannerReadOnlyTransactionOption | {
     /**
      * Sets how the timestamp will be selected when creating the snapshot.
      */
@@ -29,6 +29,10 @@ type SnapshotOptions = {
  * A function that can be passed to the {@link SpannerEntityManager.snapshot} method.
  */
 export type SnapshotFunction<T> = (snapshot: SpannerReadOnlyTransaction) => Promise<T>;
+/**
+ * A function that can be passed to the {@link SpannerEntityManager.transaction} method.
+ */
+export type SpannerTransactionFunction<T> = (transaction: SpannerReadWriteTransaction) => Promise<T>;
 /**
  * A SQL statement run using {@link SpannerEntityManager.query}.
  */
@@ -98,7 +102,7 @@ export declare class SpannerEntityManager {
      *   constructor).
      * @returns The primary key of the entity.
      */
-    getPrimaryKey<T>(entity: T | RecursivePartialEntity<T>, entityType?: Type<T>): SpannerKey;
+    getPrimaryKey<T>(entity: T | Partial<T>, entityType?: Type<T>): SpannerKey;
     /**
      * Returns the primary key of the given Spanner object, assumed to be an entity of the given type.
      *
@@ -189,7 +193,17 @@ export declare class SpannerEntityManager {
      * @param runFn The function to run in the transaction.
      * @returns The return value of the function.
      */
-    transaction<T>(runFn: (transaction: SpannerReadWriteTransaction) => Promise<T>): Promise<T>;
+    transaction<T>(runFn: SpannerTransactionFunction<T>): Promise<T>;
+    /**
+     * Runs the provided function in a (read write) {@link SpannerReadWriteTransaction}.
+     * The function itself should not commit or rollback the transaction.
+     * If the function throws an error, the transaction will be rolled back.
+     *
+     * @param options The options to use when creating the transaction.
+     * @param runFn The function to run in the transaction.
+     * @returns The return value of the function.
+     */
+    transaction<T>(options: SpannerReadWriteTransactionOption, runFn: SpannerTransactionFunction<T>): Promise<T>;
     /**
      * Runs the provided function in a {@link SpannerReadOnlyTransaction}.
      * The snapshot will be automatically released when the function returns.
@@ -288,7 +302,7 @@ export declare class SpannerEntityManager {
      * @param options Options for the operation.
      * @returns The updated entity.
      */
-    update<T>(entityType: Type<T>, update: RecursivePartialEntity<T>, options?: SpannerReadWriteTransactionOption & Pick<FindOptions, 'includeSoftDeletes'> & {
+    update<T>(entityType: Type<T>, update: Partial<T>, options?: SpannerReadWriteTransactionOption & Pick<FindOptions, 'includeSoftDeletes'> & {
         /**
          * A function that will be called with the entity before it is updated.
          * This function can throw an error to prevent the update.
@@ -316,23 +330,5 @@ export declare class SpannerEntityManager {
          */
         validateFn?: (entity: T) => void;
     }): Promise<T>;
-    /**
-     * Runs the given "read-write" function on a transaction. If a transaction is not passed, a new
-     * {@link SpannerReadWriteTransaction} is created instead.
-     *
-     * @param transaction The transaction to use. If `undefined`, a new transaction is created.
-     * @param fn The function to run on the transaction.
-     * @returns The result of the function.
-     */
-    runInExistingOrNewTransaction<T>(transaction: SpannerReadWriteTransaction | undefined, fn: (transaction: SpannerReadWriteTransaction) => Promise<T>): Promise<T>;
-    /**
-     * Runs the given "read-only" function on a transaction. If a transaction is not passed, a new
-     * {@link SpannerReadOnlyTransaction} is created instead.
-     *
-     * @param transaction The transaction to use. If `undefined`, a new {@link SpannerReadOnlyTransaction} is created.
-     * @param fn The function to run on the transaction.
-     * @returns The result of the function.
-     */
-    runInExistingOrNewReadOnlyTransaction<T>(transaction: SpannerReadOnlyTransaction | undefined, fn: SnapshotFunction<T>): Promise<T>;
 }
 export {};

package/dist/spanner/entity-manager.js

@@ -133,7 +133,7 @@ let SpannerEntityManager = class SpannerEntityManager {
         }
         const { tableName, columns: allColumns, primaryKeyColumns, softDeleteColumn, } = this.tableCache.getMetadata(entityType);
         const columns = options.columns ?? (options.index ? primaryKeyColumns : allColumns);
-        return await this.runInExistingOrNewReadOnlyTransaction(options.transaction, async (transaction) => {
+        return await this.snapshot({ transaction: options.transaction }, async (transaction) => {
             const [rows] = await transaction.read(tableName, {
                 keys: [key],
                 columns,
@@ -201,16 +201,15 @@ let SpannerEntityManager = class SpannerEntityManager {
         }
         return entity;
     }
-    /**
-     * Runs the provided function in a (read write) {@link SpannerReadWriteTransaction}.
-     * The function itself should not commit or rollback the transaction.
-     * If the function throws an error, the transaction will be rolled back.
-     *
-     * @param runFn The function to run in the transaction.
-     * @returns The return value of the function.
-     */
-    async transaction(runFn) {
+    async transaction(optionsOrRunFn, runFn) {
+        const options = runFn
+            ? optionsOrRunFn
+            : {};
+        runFn ??= optionsOrRunFn;
         try {
+            if (options.transaction) {
+                return await runFn(options.transaction);
+            }
             return await this.database.runTransactionAsync(async (transaction) => {
                 try {
                     const result = await runFn(transaction);
@@ -238,14 +237,19 @@ let SpannerEntityManager = class SpannerEntityManager {
         }
     }
     async snapshot(optionsOrRunFn, runFn) {
-        const snapshotFn = typeof optionsOrRunFn === 'function'
-            ? optionsOrRunFn
-            : runFn;
-        const options = typeof optionsOrRunFn === 'object' ? optionsOrRunFn : {};
+        const options = runFn ? optionsOrRunFn : {};
+        runFn ??= optionsOrRunFn;
         let snapshot;
         try {
-            [snapshot] = await this.database.getSnapshot(options.timestampBounds);
-            return await snapshotFn(snapshot);
+            let transaction;
+            if ('transaction' in options) {
+                transaction = options.transaction;
+            }
+            if (!transaction) {
+                [snapshot] = await this.database.getSnapshot('timestampBounds' in options ? options.timestampBounds : undefined);
+                transaction = snapshot;
+            }
+            return await runFn(transaction);
         }
         catch (error) {
             throw convertSpannerToEntityError(error) ?? error;
@@ -262,7 +266,7 @@ let SpannerEntityManager = class SpannerEntityManager {
      */
     async clear(entityType, options = {}) {
         const { quotedTableName } = this.tableCache.getMetadata(entityType);
-        await this.runInExistingOrNewTransaction(options.transaction, (transaction) => transaction.runUpdate({
+        await this.transaction(options, (transaction) => transaction.runUpdate({
             sql: `DELETE FROM ${quotedTableName} WHERE TRUE`,
         }));
     }
@@ -272,7 +276,7 @@ let SpannerEntityManager = class SpannerEntityManager {
             : {};
         const sqlStatement = statement ?? optionsOrStatement;
         const { entityType } = options;
-        return await this.runInExistingOrNewReadOnlyTransaction(options.transaction, async (transaction) => {
+        return await this.snapshot({ transaction: options.transaction }, async (transaction) => {
             const [rows] = await transaction.run({
                 ...sqlStatement,
                 json: true,
@@ -349,7 +353,7 @@ let SpannerEntityManager = class SpannerEntityManager {
      */
     async insert(entity, options = {}) {
         const objs = this.entitiesToSpannerObjects(entity);
-        await this.runInExistingOrNewTransaction(options.transaction, async (transaction) => Object.entries(objs).forEach(([tableName, objs]) => transaction.insert(tableName, objs)));
+        await this.transaction(options, async (transaction) => Object.entries(objs).forEach(([tableName, objs]) => transaction.insert(tableName, objs)));
     }
     /**
      * Replaces the given entities in the database.
@@ -364,7 +368,7 @@ let SpannerEntityManager = class SpannerEntityManager {
      */
     async replace(entity, options = {}) {
         const objs = this.entitiesToSpannerObjects(entity);
-        await this.runInExistingOrNewTransaction(options.transaction, async (transaction) => Object.entries(objs).forEach(([tableName, objs]) => transaction.replace(tableName, objs)));
+        await this.transaction(options, async (transaction) => Object.entries(objs).forEach(([tableName, objs]) => transaction.replace(tableName, objs)));
     }
     /**
      * Updates the given entity in the database.
@@ -386,7 +390,7 @@ let SpannerEntityManager = class SpannerEntityManager {
     async update(entityType, update, options = {}) {
         const primaryKey = this.getPrimaryKey(update, entityType);
         const { tableName } = this.tableCache.getMetadata(entityType);
-        return await this.runInExistingOrNewTransaction(options.transaction, async (transaction) => {
+        return await this.transaction({ transaction: options.transaction }, async (transaction) => {
             const existingEntity = await this.findOneByKey(entityType, primaryKey, {
                 transaction,
                 includeSoftDeletes: options.includeSoftDeletes,
@@ -427,7 +431,7 @@ let SpannerEntityManager = class SpannerEntityManager {
             key = [key];
         }
         const { tableName } = this.tableCache.getMetadata(entityType);
-        return await this.runInExistingOrNewTransaction(options.transaction, async (transaction) => {
+        return await this.transaction({ transaction: options.transaction }, async (transaction) => {
             const existingEntity = await this.findOneByKeyOrFail(entityType, key, {
                 transaction,
                 includeSoftDeletes: options.includeSoftDeletes,
@@ -439,44 +443,6 @@ let SpannerEntityManager = class SpannerEntityManager {
             return existingEntity;
         });
     }
-    /**
-     * Runs the given "read-write" function on a transaction. If a transaction is not passed, a new
-     * {@link SpannerReadWriteTransaction} is created instead.
-     *
-     * @param transaction The transaction to use. If `undefined`, a new transaction is created.
-     * @param fn The function to run on the transaction.
-     * @returns The result of the function.
-     */
-    async runInExistingOrNewTransaction(transaction, fn) {
-        if (transaction) {
-            try {
-                return await fn(transaction);
-            }
-            catch (error) {
-                throw convertSpannerToEntityError(error) ?? error;
-            }
-        }
-        return this.transaction(fn);
-    }
-    /**
-     * Runs the given "read-only" function on a transaction. If a transaction is not passed, a new
-     * {@link SpannerReadOnlyTransaction} is created instead.
-     *
-     * @param transaction The transaction to use. If `undefined`, a new {@link SpannerReadOnlyTransaction} is created.
-     * @param fn The function to run on the transaction.
-     * @returns The result of the function.
-     */
-    async runInExistingOrNewReadOnlyTransaction(transaction, fn) {
-        if (transaction) {
-            try {
-                return await fn(transaction);
-            }
-            catch (error) {
-                throw convertSpannerToEntityError(error) ?? error;
-            }
-        }
-        return this.snapshot(fn);
-    }
 };
 SpannerEntityManager = __decorate([
     Injectable(),

package/dist/spanner/table-cache.js

@@ -28,9 +28,6 @@ export class SpannerTableCache {
         if (softDeleteColumns.length > 1) {
             throw new InvalidEntityDefinitionError(entityType, `Only one column can be marked as soft delete.`);
         }
-        if (softDeleteColumns[0]?.nestedType) {
-            throw new InvalidEntityDefinitionError(entityType, `Soft delete columns cannot be nested.`);
-        }
         const softDeleteColumn = softDeleteColumns[0]?.name ?? null;
         const columns = getSpannerColumns(entityType);
         const quotedColumns = columns.map((c) => `\`${c}\``).join(', ');

package/dist/spanner/testing.d.ts

@@ -1,5 +1,10 @@
-import type { NestJsModuleOverrider } from '@causa/runtime/nestjs/testing';
+import type { Fixture, NestJsModuleOverrider } from '@causa/runtime/nestjs/testing';
 import { Database, Instance, Spanner } from '@google-cloud/spanner';
+import type { Type } from '@nestjs/common';
+/**
+ * Parameters for creating a new test database.
+ */
+type CreateDatabaseParameters = Pick<SpannerFixture, 'name' | 'sourceDatabaseName' | 'spanner' | 'instance'>;
 /**
  * Creates a new database.
  * This will destroy the existing database if it exists.
@@ -7,32 +12,46 @@ import { Database, Instance, Spanner } from '@google-cloud/spanner';
  * @param options Options when creating the database.
  * @returns The database object.
  */
-export declare function createDatabase(options?: {
+export declare function createDatabase(options?: Partial<CreateDatabaseParameters>): Promise<Database>;
+/**
+ * A {@link Fixture} that creates a temporary Spanner database and injects it into the NestJS application.
+ * The specified tables will be cleared after each test.
+ */
+export declare class SpannerFixture implements Fixture {
     /**
-     * The name of the database to create. If not specified, a random name will be generated.
+     * The name of the temporary database.
      */
-    name?: string;
+    readonly name: string;
     /**
      * If `sourceDatabaseName` is provided, its DDL will be copied into the new database, otherwise it will try to copy
      * the DDL from `process.env.SPANNER_DATABASE`.
      * If `null`, no schema will be set on the created database.
      */
-    sourceDatabaseName?: string | null;
+    readonly sourceDatabaseName: string | null;
     /**
-     * The instance on which the database should be created.
+     * The Spanner client to use for tests.
+     */
+    readonly spanner: Spanner;
+    /**
+     * The Spanner instance to use for tests.
      * By default, a new Spanner client will be created using the `SPANNER_INSTANCE` environment variable.
      */
-    instance?: Instance;
+    readonly instance: Instance;
     /**
-     * The Spanner client to use to create the database.
-     * If `instance` is provided, this will be ignored.
+     * Types of entities (Spanner tables) to clear.
      */
-    spanner?: Spanner;
-}): Promise<Database>;
-/**
- * Returns a {@link NestJsModuleOverrider} that overrides the {@link Database} provider with the provided database.
- *
- * @param database The temporary database to use.
- * @returns The {@link NestJsModuleOverrider} to override the {@link Database} provider.
- */
-export declare function overrideDatabase(database: Database): NestJsModuleOverrider;
+    readonly types: Type[];
+    /**
+     * The {@link SpannerEntityManager} used to clear tables.
+     */
+    private entityManager;
+    /**
+     * The temporary test database created by this fixture.
+     */
+    private database;
+    constructor(options?: Partial<CreateDatabaseParameters> & Partial<Pick<SpannerFixture, 'types'>>);
+    init(): Promise<NestJsModuleOverrider>;
+    clear(): Promise<void>;
+    delete(): Promise<void>;
+}
+export {};