@tstdl/base 0.93.162 → 0.93.164

package/testing/integration-setup.d.ts

@@ -8,11 +8,11 @@ import { type S3ObjectStorageProviderConfig } from '../object-storage/s3/index.j
 import type { EntityType } from '../orm/entity.js';
 import { Database } from '../orm/server/index.js';
 import type { Type } from '../types/index.js';
-import { type ValueOrProvider } from '../utils/value-or-provider.js';
 export type IntegrationTestOptions = {
     dbConfig?: Partial<PoolConfig>;
     orm?: {
         schema?: string;
+        encryptionSecret?: Uint8Array;
     };
     api?: {
         baseUrl?: string;
@@ -37,23 +37,70 @@ export type IntegrationTestOptions = {
         webServer?: boolean;
     };
     authenticationAncillaryService?: Type<AuthenticationAncillaryService>;
+    /**
+     * If true, a fresh context will be created and it will be disposed after the test.
+     * If false (default), the context is shared across tests with the same options and is NOT disposed automatically.
+     */
+    isolated?: boolean;
 };
 export type TestContext = {
     injector: Injector;
     database: Database;
 };
+export type IntegrationTestFixtures = {
+    options: IntegrationTestOptions;
+    context: TestContext;
+    injector: Injector;
+    database: Database;
+};
 /**
  * Standard setup for integration tests.
+ * By default, this caches the context based on the provided options to improve performance.
+ * For a fresh context, use {@link setupIsolatedIntegrationTest} or set `options.isolated` to true.
  */
 export declare function setupIntegrationTest(options?: IntegrationTestOptions): Promise<TestContext>;
 /**
- * A wrapper for vitest's `test` that automatically runs the test function in the provided injector's context.
- * @param name The name of the test.
- * @param injector The injector to use for the context.
- * @param fn The test function.
- * @param options Vitest test options.
+ * Creates a fresh, non-cached integration test context.
  */
-export declare function testInInjector(name: string, injector: ValueOrProvider<Injector>, fn: () => any, options?: number | TestOptions): void;
+export declare function setupIsolatedIntegrationTest(options?: IntegrationTestOptions): Promise<TestContext>;
+export declare const integrationTest: import("vitest").TestAPI<{
+    injector: Injector;
+    options: IntegrationTestOptions;
+    context: TestContext;
+    database: Database;
+}>;
+export declare function getIntegrationTest(options: IntegrationTestOptions): {
+    (name: string, fn: import("vitest").TestFunction<{
+        injector: Injector;
+        options: IntegrationTestOptions;
+        context: TestContext;
+        database: Database;
+    }> | undefined, options?: number | TestOptions): void;
+    beforeEach: (fn: import("@vitest/runner").BeforeEachListener<{
+        injector: Injector;
+        options: IntegrationTestOptions;
+        context: TestContext;
+        database: Database;
+    }>, timeout?: number) => void;
+    afterEach: (fn: import("@vitest/runner").AfterEachListener<{
+        injector: Injector;
+        options: IntegrationTestOptions;
+        context: TestContext;
+        database: Database;
+    }>, timeout?: number) => void;
+    beforeAll: (this: unknown, fn: import("@vitest/runner").BeforeAllListener<{
+        injector: Injector;
+        options: IntegrationTestOptions;
+        context: TestContext;
+        database: Database;
+    }>, timeout?: number) => void;
+    afterAll: (this: unknown, fn: import("@vitest/runner").AfterAllListener<{
+        injector: Injector;
+        options: IntegrationTestOptions;
+        context: TestContext;
+        database: Database;
+    }>, timeout?: number) => void;
+};
 /**
  * Helper to truncate specific tables in a schema.
  * Useful in beforeEach() to reset state.

package/testing/integration-setup.js

@@ -1,6 +1,58 @@
 /** biome-ignore-all lint/nursery/useExpect: helper file */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { sql } from 'drizzle-orm';
-import { afterAll, test } from 'vitest';
+import { test as baseTest } from 'vitest';
 import { configureApiServer } from '../api/server/index.js';
 import { configureAudit } from '../audit/index.js';
 import { AuthenticationApiClient } from '../authentication/client/api.client.js';
@@ -25,14 +77,36 @@ import { getEntitySchema, getEntityTableName } from '../orm/utils.js';
 import { configurePostgresRateLimiter } from '../rate-limit/postgres/module.js';
 import { configureDefaultSignalsImplementation } from '../signals/implementation/configure.js';
 import { configurePostgresTaskQueue } from '../task-queue/postgres/index.js';
+import { encodeBase64 } from '../utils/base64.js';
 import * as configParser from '../utils/config-parser.js';
 import { objectEntries } from '../utils/object/object.js';
-import { assertDefinedPass, isDefined, isNotNull, isNumber, isString, isUndefined } from '../utils/type-guards.js';
-import { resolveValueOrProvider } from '../utils/value-or-provider.js';
+import { assertDefinedPass, isDefined, isFunction, isNotNull, isNumber, isString, isUint8Array, isUndefined } from '../utils/type-guards.js';
+const sharedContexts = new Map();
 /**
  * Standard setup for integration tests.
+ * By default, this caches the context based on the provided options to improve performance.
+ * For a fresh context, use {@link setupIsolatedIntegrationTest} or set `options.isolated` to true.
  */
 export async function setupIntegrationTest(options = {}) {
+    if (options.isolated == true) {
+        return await setupIsolatedIntegrationTest(options);
+    }
+    const key = getOptionsKey(options);
+    let contextPromise = sharedContexts.get(key);
+    if (isUndefined(contextPromise)) {
+        contextPromise = setupIsolatedIntegrationTest(options);
+        sharedContexts.set(key, contextPromise);
+    }
+    const context = await contextPromise;
+    if (!context.injector.disposed) {
+        context.injector.addDisposeHandler(() => sharedContexts.delete(key));
+    }
+    return context;
+}
+/**
+ * Creates a fresh, non-cached integration test context.
+ */
+export async function setupIsolatedIntegrationTest(options = {}) {
     const injector = new Injector('TestInjector');
     // 1. Logger Setup
     injector.register(LogFormatter, { useToken: PrettyPrintLogFormatter });
@@ -60,6 +134,7 @@ export async function setupIntegrationTest(options = {}) {
     configureOrm({
         repositoryConfig: { schema: options.orm?.schema ?? 'test' },
         connection: dbConfig,
+        encryptionSecret: options.orm?.encryptionSecret,
         injector,
     });
     // 5. Database Resolution
@@ -165,27 +240,67 @@ export async function setupIntegrationTest(options = {}) {
             }
         }
     });
-    afterAll(async () => await injector.dispose());
     return { injector, database };
 }
-/**
- * A wrapper for vitest's `test` that automatically runs the test function in the provided injector's context.
- * @param name The name of the test.
- * @param injector The injector to use for the context.
- * @param fn The test function.
- * @param options Vitest test options.
- */
-export function testInInjector(name, injector, fn, options) {
-    if (isUndefined(options) || isNumber(options)) {
-        test(name, async () => {
-            await runInInjectionContext(resolveValueOrProvider(injector), fn);
-        }, options);
-    }
-    else {
-        test(name, options, async () => {
-            await runInInjectionContext(resolveValueOrProvider(injector), fn);
-        });
+export const integrationTest = baseTest.extend({
+    options: {},
+    context: async ({ options }, use) => {
+        const context = await setupIntegrationTest(options);
+        if (options.isolated == true) {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const stack = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
+                stack.use(context.injector);
+                await use(context);
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                const result_1 = __disposeResources(env_1);
+                if (result_1)
+                    await result_1;
+            }
+        }
+        else {
+            await use(context);
+        }
+    },
+    injector: async ({ context }, use) => {
+        await use(context.injector);
+    },
+    database: async ({ context }, use) => {
+        await use(context.database);
+    },
+});
+export function getIntegrationTest(options) {
+    const customTest = integrationTest.extend({ options });
+    /**
+     * A wrapper for vitest's `test` that automatically runs the test function in the provided injector's context.
+     * @param name The name of the test.
+     * @param injector The injector to use for the context.
+     * @param fn The test function.
+     * @param options Vitest test options.
+     */
+    function test(name, fn, options) {
+        if (isUndefined(options) || isNumber(options)) {
+            customTest(name, async ({ options, context, injector, database, task, signal, skip, annotate, expect, _local, onTestFailed, onTestFinished }) => {
+                await runInInjectionContext(injector, () => fn?.({ options, context, injector, database, task, signal, skip, annotate, expect, _local, onTestFailed, onTestFinished })); // eslint-disable-line @typescript-eslint/no-unsafe-return
+            }, options);
+        }
+        else {
+            customTest(name, options, async ({ options, context, injector, database, task, signal, skip, annotate, expect, _local, onTestFailed, onTestFinished }) => {
+                await runInInjectionContext(injector, () => fn?.({ options, context, injector, database, task, signal, skip, annotate, expect, _local, onTestFailed, onTestFinished })); // eslint-disable-line @typescript-eslint/no-unsafe-return
+            });
+        }
     }
+    ;
+    test.beforeEach = customTest.beforeEach;
+    test.afterEach = customTest.afterEach;
+    test.beforeAll = customTest.beforeAll;
+    test.afterAll = customTest.afterAll;
+    return test;
 }
 /**
  * Helper to truncate specific tables in a schema.
@@ -270,3 +385,14 @@ async function runWithAdvisoryLock(database, lockName, fn) {
         await new Promise((resolve) => setTimeout(resolve, 10 + Math.random() * 90));
     }
 }
+function getOptionsKey(options) {
+    return JSON.stringify(options, (_key, value) => {
+        if (isFunction(value)) {
+            return value.name;
+        }
+        if (isUint8Array(value)) {
+            return encodeBase64(value);
+        }
+        return String(value);
+    });
+}