@zenstackhq/testtools 3.0.0-beta.9 → 3.0.0

package/dist/index.d.cts

@@ -1,41 +1,89 @@
-import { ClientOptions, ClientContract } from '@zenstackhq/runtime';
-import { SchemaDef } from '@zenstackhq/runtime/schema';
+import { ClientOptions, ClientContract } from '@zenstackhq/orm';
+import { SchemaDef } from '@zenstackhq/orm/schema';
 import { LogEvent } from 'kysely';
 import * as _zenstackhq_language_ast from '@zenstackhq/language/ast';
-import { SchemaDef as SchemaDef$1 } from '@zenstackhq/sdk/schema';
+import { SchemaDef as SchemaDef$1 } from '@zenstackhq/schema';
 
 declare function getTestDbProvider(): "sqlite" | "postgresql";
-type CreateTestClientOptions<Schema extends SchemaDef> = Omit<ClientOptions<Schema>, 'dialect'> & {
+declare const TEST_PG_CONFIG: {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+};
+declare const TEST_PG_URL: string;
+type ExtraTestClientOptions = {
+    /**
+     * Database provider
+     */
     provider?: 'sqlite' | 'postgresql';
+    /**
+     * The main ZModel file. Only used when `usePrismaPush` is true and `schema` is an object.
+     */
+    schemaFile?: string;
+    /**
+     * Database name. If not provided, a name will be generated based on the test name.
+     */
     dbName?: string;
+    /**
+     * Use `prisma db push` instead of ZenStack's `$pushSchema` for database initialization.
+     */
     usePrismaPush?: boolean;
+    /**
+     * Extra source files to create and compile.
+     */
     extraSourceFiles?: Record<string, string>;
+    /**
+     * Working directory for the test client. If not provided, a temporary directory will be created.
+     */
     workDir?: string;
+    /**
+     * Debug mode.
+     */
     debug?: boolean;
+    /**
+     * A sqlite database file to be used for the test. Only supported for sqlite provider.
+     */
+    dbFile?: string;
+    /**
+     * PostgreSQL extensions to be added to the datasource. Only supported for postgresql provider.
+     */
+    dataSourceExtensions?: string[];
+    /**
+     * Additional files to be copied to the working directory. The glob pattern is relative to the test file.
+     */
+    copyFiles?: {
+        globPattern: string;
+        destination: string;
+    }[];
 };
-declare function createTestClient<Schema extends SchemaDef>(schema: Schema, options?: CreateTestClientOptions<Schema>, schemaFile?: string): Promise<ClientContract<Schema>>;
-declare function createTestClient<Schema extends SchemaDef>(schema: string, options?: CreateTestClientOptions<Schema>): Promise<any>;
+type CreateTestClientOptions<Schema extends SchemaDef> = Omit<ClientOptions<Schema>, 'dialect'> & ExtraTestClientOptions;
+declare function createTestClient<Schema extends SchemaDef, Options extends ClientOptions<Schema>, CreateOptions = Omit<Options, 'dialect'>>(schema: Schema, options?: CreateOptions): Promise<ClientContract<Schema, Options>>;
+declare function createTestClient(schema: string, options?: CreateTestClientOptions<SchemaDef>): Promise<any>;
 declare function createPolicyTestClient<Schema extends SchemaDef>(schema: Schema, options?: CreateTestClientOptions<Schema>): Promise<ClientContract<Schema>>;
 declare function createPolicyTestClient<Schema extends SchemaDef>(schema: string, options?: CreateTestClientOptions<Schema>): Promise<any>;
 declare function testLogger(e: LogEvent): void;
 
 declare function createTestProject(zmodelContent?: string): string;
 
-declare function generateTsSchema(schemaText: string, provider?: 'sqlite' | 'postgresql', dbUrl?: string, extraSourceFiles?: Record<string, string>): Promise<{
+declare function generateTsSchema(schemaText: string, provider?: 'sqlite' | 'postgresql', dbUrl?: string, extraSourceFiles?: Record<string, string>, withLiteSchema?: boolean): Promise<{
     model: _zenstackhq_language_ast.Model;
     workDir: string;
     schema: SchemaDef$1;
+    schemaLite: SchemaDef$1 | undefined;
 }>;
 declare function generateTsSchemaFromFile(filePath: string): Promise<{
     model: _zenstackhq_language_ast.Model;
     workDir: string;
     schema: SchemaDef$1;
+    schemaLite: SchemaDef$1 | undefined;
 }>;
 declare function generateTsSchemaInPlace(schemaPath: string): Promise<{
     workDir: string;
     schema: SchemaDef$1;
+    schemaLite: SchemaDef$1 | undefined;
 }>;
 declare function loadSchema(schema: string, additionalSchemas?: Record<string, string>): Promise<_zenstackhq_language_ast.Model>;
 declare function loadSchemaWithError(schema: string, error: string | RegExp): Promise<void>;
 
-export { type CreateTestClientOptions, createPolicyTestClient, createTestClient, createTestProject, generateTsSchema, generateTsSchemaFromFile, generateTsSchemaInPlace, getTestDbProvider, loadSchema, loadSchemaWithError, testLogger };
+export { type CreateTestClientOptions, TEST_PG_CONFIG, TEST_PG_URL, createPolicyTestClient, createTestClient, createTestProject, generateTsSchema, generateTsSchemaFromFile, generateTsSchemaInPlace, getTestDbProvider, loadSchema, loadSchemaWithError, testLogger };

package/dist/index.d.ts

@@ -1,41 +1,89 @@
-import { ClientOptions, ClientContract } from '@zenstackhq/runtime';
-import { SchemaDef } from '@zenstackhq/runtime/schema';
+import { ClientOptions, ClientContract } from '@zenstackhq/orm';
+import { SchemaDef } from '@zenstackhq/orm/schema';
 import { LogEvent } from 'kysely';
 import * as _zenstackhq_language_ast from '@zenstackhq/language/ast';
-import { SchemaDef as SchemaDef$1 } from '@zenstackhq/sdk/schema';
+import { SchemaDef as SchemaDef$1 } from '@zenstackhq/schema';
 
 declare function getTestDbProvider(): "sqlite" | "postgresql";
-type CreateTestClientOptions<Schema extends SchemaDef> = Omit<ClientOptions<Schema>, 'dialect'> & {
+declare const TEST_PG_CONFIG: {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+};
+declare const TEST_PG_URL: string;
+type ExtraTestClientOptions = {
+    /**
+     * Database provider
+     */
     provider?: 'sqlite' | 'postgresql';
+    /**
+     * The main ZModel file. Only used when `usePrismaPush` is true and `schema` is an object.
+     */
+    schemaFile?: string;
+    /**
+     * Database name. If not provided, a name will be generated based on the test name.
+     */
     dbName?: string;
+    /**
+     * Use `prisma db push` instead of ZenStack's `$pushSchema` for database initialization.
+     */
     usePrismaPush?: boolean;
+    /**
+     * Extra source files to create and compile.
+     */
     extraSourceFiles?: Record<string, string>;
+    /**
+     * Working directory for the test client. If not provided, a temporary directory will be created.
+     */
     workDir?: string;
+    /**
+     * Debug mode.
+     */
     debug?: boolean;
+    /**
+     * A sqlite database file to be used for the test. Only supported for sqlite provider.
+     */
+    dbFile?: string;
+    /**
+     * PostgreSQL extensions to be added to the datasource. Only supported for postgresql provider.
+     */
+    dataSourceExtensions?: string[];
+    /**
+     * Additional files to be copied to the working directory. The glob pattern is relative to the test file.
+     */
+    copyFiles?: {
+        globPattern: string;
+        destination: string;
+    }[];
 };
-declare function createTestClient<Schema extends SchemaDef>(schema: Schema, options?: CreateTestClientOptions<Schema>, schemaFile?: string): Promise<ClientContract<Schema>>;
-declare function createTestClient<Schema extends SchemaDef>(schema: string, options?: CreateTestClientOptions<Schema>): Promise<any>;
+type CreateTestClientOptions<Schema extends SchemaDef> = Omit<ClientOptions<Schema>, 'dialect'> & ExtraTestClientOptions;
+declare function createTestClient<Schema extends SchemaDef, Options extends ClientOptions<Schema>, CreateOptions = Omit<Options, 'dialect'>>(schema: Schema, options?: CreateOptions): Promise<ClientContract<Schema, Options>>;
+declare function createTestClient(schema: string, options?: CreateTestClientOptions<SchemaDef>): Promise<any>;
 declare function createPolicyTestClient<Schema extends SchemaDef>(schema: Schema, options?: CreateTestClientOptions<Schema>): Promise<ClientContract<Schema>>;
 declare function createPolicyTestClient<Schema extends SchemaDef>(schema: string, options?: CreateTestClientOptions<Schema>): Promise<any>;
 declare function testLogger(e: LogEvent): void;
 
 declare function createTestProject(zmodelContent?: string): string;
 
-declare function generateTsSchema(schemaText: string, provider?: 'sqlite' | 'postgresql', dbUrl?: string, extraSourceFiles?: Record<string, string>): Promise<{
+declare function generateTsSchema(schemaText: string, provider?: 'sqlite' | 'postgresql', dbUrl?: string, extraSourceFiles?: Record<string, string>, withLiteSchema?: boolean): Promise<{
     model: _zenstackhq_language_ast.Model;
     workDir: string;
     schema: SchemaDef$1;
+    schemaLite: SchemaDef$1 | undefined;
 }>;
 declare function generateTsSchemaFromFile(filePath: string): Promise<{
     model: _zenstackhq_language_ast.Model;
     workDir: string;
     schema: SchemaDef$1;
+    schemaLite: SchemaDef$1 | undefined;
 }>;
 declare function generateTsSchemaInPlace(schemaPath: string): Promise<{
     workDir: string;
     schema: SchemaDef$1;
+    schemaLite: SchemaDef$1 | undefined;
 }>;
 declare function loadSchema(schema: string, additionalSchemas?: Record<string, string>): Promise<_zenstackhq_language_ast.Model>;
 declare function loadSchemaWithError(schema: string, error: string | RegExp): Promise<void>;
 
-export { type CreateTestClientOptions, createPolicyTestClient, createTestClient, createTestProject, generateTsSchema, generateTsSchemaFromFile, generateTsSchemaInPlace, getTestDbProvider, loadSchema, loadSchemaWithError, testLogger };
+export { type CreateTestClientOptions, TEST_PG_CONFIG, TEST_PG_URL, createPolicyTestClient, createTestClient, createTestProject, generateTsSchema, generateTsSchemaFromFile, generateTsSchemaInPlace, getTestDbProvider, loadSchema, loadSchemaWithError, testLogger };

package/dist/index.js

@@ -1,13 +1,19 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/client.ts
 import { invariant as invariant2 } from "@zenstackhq/common-helpers";
-import { loadDocument as loadDocument2 } from "@zenstackhq/language";
+import { ZenStackClient } from "@zenstackhq/orm";
 import { PolicyPlugin } from "@zenstackhq/plugin-policy";
-import { ZenStackClient } from "@zenstackhq/runtime";
 import { PrismaSchemaGenerator } from "@zenstackhq/sdk";
 import SQLite from "better-sqlite3";
+import { glob } from "glob";
 import { PostgresDialect, SqliteDialect } from "kysely";
 import { execSync as execSync2 } from "child_process";
 import { createHash } from "crypto";
@@ -35,7 +41,7 @@ function createTestProject(zmodelContent) {
   const zenstackPackages = [
     "language",
     "sdk",
-    "runtime",
+    "orm",
     "cli"
   ];
   fs.mkdirSync(path.join(workDir, "node_modules/@zenstackhq"));
@@ -69,7 +75,6 @@ __name(createTestProject, "createTestProject");
 
 // src/schema.ts
 import { invariant } from "@zenstackhq/common-helpers";
-import { loadDocument } from "@zenstackhq/language";
 import { TsSchemaGenerator } from "@zenstackhq/sdk";
 import { execSync } from "child_process";
 import crypto from "crypto";
@@ -78,6 +83,18 @@ import os from "os";
 import path2 from "path";
 import { match } from "ts-pattern";
 import { expect } from "vitest";
+
+// src/utils.ts
+import { loadDocument } from "@zenstackhq/language";
+function loadDocumentWithPlugins(filePath) {
+  const pluginModelFiles = [
+    __require.resolve("@zenstackhq/plugin-policy/plugin.zmodel")
+  ];
+  return loadDocument(filePath, pluginModelFiles);
+}
+__name(loadDocumentWithPlugins, "loadDocumentWithPlugins");
+
+// src/schema.ts
 function makePrelude(provider, dbUrl) {
   return match(provider).with("sqlite", () => {
     return `
@@ -96,19 +113,27 @@ datasource db {
   }).exhaustive();
 }
 __name(makePrelude, "makePrelude");
-async function generateTsSchema(schemaText, provider = "sqlite", dbUrl, extraSourceFiles) {
+function replacePlaceholders(schemaText, provider, dbUrl) {
+  const url = dbUrl ?? (provider === "sqlite" ? "file:./test.db" : "postgres://postgres:postgres@localhost:5432/db");
+  return schemaText.replace(/\$DB_URL/g, url).replace(/\$PROVIDER/g, provider);
+}
+__name(replacePlaceholders, "replacePlaceholders");
+async function generateTsSchema(schemaText, provider = "sqlite", dbUrl, extraSourceFiles, withLiteSchema) {
   const workDir = createTestProject();
   const zmodelPath = path2.join(workDir, "schema.zmodel");
   const noPrelude = schemaText.includes("datasource ");
   fs2.writeFileSync(zmodelPath, `${noPrelude ? "" : makePrelude(provider, dbUrl)}
 
-${schemaText}`);
-  const result = await loadDocument(zmodelPath);
+${replacePlaceholders(schemaText, provider, dbUrl)}`);
+  const result = await loadDocumentWithPlugins(zmodelPath);
   if (!result.success) {
     throw new Error(`Failed to load schema from ${zmodelPath}: ${result.errors}`);
   }
   const generator = new TsSchemaGenerator();
-  await generator.generate(result.model, workDir);
+  await generator.generate(result.model, {
+    outDir: workDir,
+    lite: withLiteSchema
+  });
   if (extraSourceFiles) {
     for (const [fileName, content] of Object.entries(extraSourceFiles)) {
       const filePath = path2.resolve(workDir, !fileName.endsWith(".ts") ? `${fileName}.ts` : fileName);
@@ -130,9 +155,15 @@ async function compileAndLoad(workDir) {
     stdio: "inherit"
   });
   const module = await import(path2.join(workDir, "schema.js"));
+  let moduleLite;
+  try {
+    moduleLite = await import(path2.join(workDir, "schema-lite.js"));
+  } catch {
+  }
   return {
     workDir,
-    schema: module.schema
+    schema: module.schema,
+    schemaLite: moduleLite?.schema
   };
 }
 __name(compileAndLoad, "compileAndLoad");
@@ -143,12 +174,14 @@ function generateTsSchemaFromFile(filePath) {
 __name(generateTsSchemaFromFile, "generateTsSchemaFromFile");
 async function generateTsSchemaInPlace(schemaPath) {
   const workDir = path2.dirname(schemaPath);
-  const result = await loadDocument(schemaPath);
+  const result = await loadDocumentWithPlugins(schemaPath);
   if (!result.success) {
     throw new Error(`Failed to load schema from ${schemaPath}: ${result.errors}`);
   }
   const generator = new TsSchemaGenerator();
-  await generator.generate(result.model, workDir);
+  await generator.generate(result.model, {
+    outDir: workDir
+  });
   return compileAndLoad(workDir);
 }
 __name(generateTsSchemaInPlace, "generateTsSchemaInPlace");
@@ -171,7 +204,7 @@ ${schema}`;
       fs2.writeFileSync(filePath, content);
     }
   }
-  const r = await loadDocument(tempFile);
+  const r = await loadDocumentWithPlugins(tempFile);
   expect(r).toSatisfy((r2) => r2.success, `Failed to load schema: ${r.errors?.map((e) => e.toString()).join(", ")}`);
   invariant(r.success);
   return r.model;
@@ -185,7 +218,7 @@ ${schema}`;
   }
   const tempFile = path2.join(os.tmpdir(), `zenstack-schema-${crypto.randomUUID()}.zmodel`);
   fs2.writeFileSync(tempFile, schema);
-  const r = await loadDocument(tempFile);
+  const r = await loadDocumentWithPlugins(tempFile);
   expect(r.success).toBe(false);
   invariant(!r.success);
   if (typeof error === "string") {
@@ -214,20 +247,22 @@ var TEST_PG_CONFIG = {
   user: process.env["TEST_PG_USER"] ?? "postgres",
   password: process.env["TEST_PG_PASSWORD"] ?? "postgres"
 };
-async function createTestClient(schema, options, schemaFile) {
+var TEST_PG_URL = `postgres://${TEST_PG_CONFIG.user}:${TEST_PG_CONFIG.password}@${TEST_PG_CONFIG.host}:${TEST_PG_CONFIG.port}`;
+async function createTestClient(schema, options) {
   let workDir = options?.workDir;
   let _schema;
   const provider = options?.provider ?? getTestDbProvider() ?? "sqlite";
   const dbName = options?.dbName ?? getTestDbName(provider);
-  const dbUrl = provider === "sqlite" ? `file:${dbName}` : `postgres://${TEST_PG_CONFIG.user}:${TEST_PG_CONFIG.password}@${TEST_PG_CONFIG.host}:${TEST_PG_CONFIG.port}/${dbName}`;
+  const dbUrl = provider === "sqlite" ? `file:${dbName}` : `${TEST_PG_URL}/${dbName}`;
   let model;
   if (typeof schema === "string") {
-    const generated = await generateTsSchema(schema, provider, dbUrl, options?.extraSourceFiles);
+    const generated = await generateTsSchema(schema, provider, dbUrl, options?.extraSourceFiles, void 0);
     workDir = generated.workDir;
     model = generated.model;
     _schema = {
       ...generated.schema,
       provider: {
+        ...generated.schema.provider,
         type: provider
       }
     };
@@ -239,49 +274,80 @@ async function createTestClient(schema, options, schemaFile) {
       }
     };
     workDir ??= createTestProject();
-    if (schemaFile) {
-      let schemaContent = fs3.readFileSync(schemaFile, "utf-8");
+    if (options?.schemaFile) {
+      let schemaContent = fs3.readFileSync(options.schemaFile, "utf-8");
       if (dbUrl) {
         schemaContent = schemaContent.replace(/datasource\s+db\s*{[^}]*}/m, `datasource db {
     provider = '${provider}'
     url = '${dbUrl}'
+    ${options.dataSourceExtensions ? `extensions = [${options.dataSourceExtensions.join(", ")}]` : ""}
 }`);
       }
       fs3.writeFileSync(path3.join(workDir, "schema.zmodel"), schemaContent);
     }
   }
   invariant2(workDir);
-  if (options?.debug) {
-    console.log(`Work directory: ${workDir}`);
-  }
   const { plugins, ...rest } = options ?? {};
   const _options = {
     ...rest
   };
-  if (options?.usePrismaPush) {
-    invariant2(typeof schema === "string" || schemaFile, "a schema file must be provided when using prisma db push");
-    if (!model) {
-      const r = await loadDocument2(path3.join(workDir, "schema.zmodel"));
-      if (!r.success) {
-        throw new Error(r.errors.join("\n"));
+  if (options?.debug) {
+    console.log(`Work directory: ${workDir}`);
+    console.log(`Database name: ${dbName}`);
+    _options.log = testLogger;
+  }
+  if (options?.dbFile) {
+    if (provider !== "sqlite") {
+      throw new Error("dbFile option is only supported for sqlite provider");
+    }
+    fs3.copyFileSync(options.dbFile, path3.join(workDir, dbName));
+  }
+  if (options?.copyFiles) {
+    const state = expect2.getState();
+    const currentTestPath = state.testPath;
+    if (!currentTestPath) {
+      throw new Error("Unable to determine current test file path");
+    }
+    for (const { globPattern, destination } of options.copyFiles) {
+      const files = glob.sync(globPattern, {
+        cwd: path3.dirname(currentTestPath)
+      });
+      for (const file of files) {
+        const src = path3.resolve(path3.dirname(currentTestPath), file);
+        const dest = path3.resolve(workDir, destination, path3.basename(file));
+        fs3.mkdirSync(path3.dirname(dest), {
+          recursive: true
+        });
+        fs3.copyFileSync(src, dest);
       }
-      model = r.model;
     }
-    const prismaSchema = new PrismaSchemaGenerator(model);
-    const prismaSchemaText = await prismaSchema.generate();
-    fs3.writeFileSync(path3.resolve(workDir, "schema.prisma"), prismaSchemaText);
-    execSync2("npx prisma db push --schema ./schema.prisma --skip-generate --force-reset", {
-      cwd: workDir,
-      stdio: "ignore"
-    });
-  } else {
-    if (provider === "postgresql") {
-      invariant2(dbName, "dbName is required");
-      const pgClient = new PGClient(TEST_PG_CONFIG);
-      await pgClient.connect();
-      await pgClient.query(`DROP DATABASE IF EXISTS "${dbName}"`);
-      await pgClient.query(`CREATE DATABASE "${dbName}"`);
-      await pgClient.end();
+  }
+  if (!options?.dbFile) {
+    if (options?.usePrismaPush) {
+      invariant2(typeof schema === "string" || options?.schemaFile, "a schema file must be provided when using prisma db push");
+      if (!model) {
+        const r = await loadDocumentWithPlugins(path3.join(workDir, "schema.zmodel"));
+        if (!r.success) {
+          throw new Error(r.errors.join("\n"));
+        }
+        model = r.model;
+      }
+      const prismaSchema = new PrismaSchemaGenerator(model);
+      const prismaSchemaText = await prismaSchema.generate();
+      fs3.writeFileSync(path3.resolve(workDir, "schema.prisma"), prismaSchemaText);
+      execSync2("npx prisma db push --schema ./schema.prisma --skip-generate --force-reset", {
+        cwd: workDir,
+        stdio: "ignore"
+      });
+    } else {
+      if (provider === "postgresql") {
+        invariant2(dbName, "dbName is required");
+        const pgClient = new PGClient(TEST_PG_CONFIG);
+        await pgClient.connect();
+        await pgClient.query(`DROP DATABASE IF EXISTS "${dbName}"`);
+        await pgClient.query(`CREATE DATABASE "${dbName}"`);
+        await pgClient.end();
+      }
     }
   }
   if (provider === "postgresql") {
@@ -297,7 +363,7 @@ async function createTestClient(schema, options, schemaFile) {
     });
   }
   let client = new ZenStackClient(_schema, _options);
-  if (!options?.usePrismaPush) {
+  if (!options?.usePrismaPush && !options?.dbFile) {
     await client.$pushSchema();
   }
   if (plugins) {
@@ -326,38 +392,37 @@ function getTestDbName(provider) {
   if (provider === "sqlite") {
     return "./test.db";
   }
-  const testName = expect2.getState().currentTestName;
+  const testName = expect2.getState().currentTestName ?? "unnamed";
   const testPath = expect2.getState().testPath ?? "";
-  invariant2(testName);
   const digest = createHash("md5").update(testName + testPath).digest("hex");
   return "test_" + testName.toLowerCase().replace(/[^a-z0-9_]/g, "_").replace(/_+/g, "_").substring(0, 30) + digest.slice(0, 6);
 }
 __name(getTestDbName, "getTestDbName");
 
 // src/vitest-ext.ts
-import { InputValidationError, NotFoundError, RejectedByPolicyError } from "@zenstackhq/runtime";
+import { ORMError, ORMErrorReason } from "@zenstackhq/orm";
 import { expect as expect3 } from "vitest";
 function isPromise(value) {
   return typeof value.then === "function" && typeof value.catch === "function";
 }
 __name(isPromise, "isPromise");
-function expectError(err, errorType) {
-  if (err instanceof errorType) {
+function expectErrorReason(err, errorReason) {
+  if (err instanceof ORMError && err.reason === errorReason) {
     return {
       message: /* @__PURE__ */ __name(() => "", "message"),
       pass: true
     };
   } else {
     return {
-      message: /* @__PURE__ */ __name(() => `expected ${errorType}, got ${err}`, "message"),
+      message: /* @__PURE__ */ __name(() => `expected ORMError of reason ${errorReason}, got ${err}`, "message"),
       pass: false
     };
   }
 }
-__name(expectError, "expectError");
+__name(expectErrorReason, "expectErrorReason");
 function expectErrorMessages(expectedMessages, message) {
   for (const m of expectedMessages) {
-    if (!message.includes(m)) {
+    if (!message.toLowerCase().includes(m.toLowerCase())) {
       return {
         message: /* @__PURE__ */ __name(() => `expected message not found in error: ${m}, got message: ${message}`, "message"),
         pass: false
@@ -424,7 +489,7 @@ expect3.extend({
     try {
       await received;
     } catch (err) {
-      return expectError(err, NotFoundError);
+      return expectErrorReason(err, ORMErrorReason.NOT_FOUND);
     }
     return {
       message: /* @__PURE__ */ __name(() => `expected NotFoundError, got no error`, "message"),
@@ -441,13 +506,13 @@ expect3.extend({
     try {
       await received;
     } catch (err) {
-      if (expectedMessages && err instanceof RejectedByPolicyError) {
+      if (expectedMessages && err instanceof ORMError && err.reason === ORMErrorReason.REJECTED_BY_POLICY) {
         const r = expectErrorMessages(expectedMessages, err.message || "");
         if (r) {
           return r;
         }
       }
-      return expectError(err, RejectedByPolicyError);
+      return expectErrorReason(err, ORMErrorReason.REJECTED_BY_POLICY);
     }
     return {
       message: /* @__PURE__ */ __name(() => `expected PolicyError, got no error`, "message"),
@@ -464,13 +529,13 @@ expect3.extend({
     try {
       await received;
     } catch (err) {
-      if (expectedMessages && err instanceof InputValidationError) {
+      if (expectedMessages && err instanceof ORMError && err.reason === ORMErrorReason.INVALID_INPUT) {
         const r = expectErrorMessages(expectedMessages, err.message || "");
         if (r) {
           return r;
         }
       }
-      return expectError(err, InputValidationError);
+      return expectErrorReason(err, ORMErrorReason.INVALID_INPUT);
     }
     return {
       message: /* @__PURE__ */ __name(() => `expected InputValidationError, got no error`, "message"),
@@ -479,6 +544,8 @@ expect3.extend({
   }
 });
 export {
+  TEST_PG_CONFIG,
+  TEST_PG_URL,
   createPolicyTestClient,
   createTestClient,
   createTestProject,