@zenstackhq/testtools 3.0.0-beta.2 → 3.0.0-beta.21

package/dist/index.d.cts

@@ -1,18 +1,46 @@
-import { SchemaDef } from '@zenstackhq/sdk/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/schema';
 
-declare function createTestProject(): string;
+declare function getTestDbProvider(): "sqlite" | "postgresql";
+type CreateTestClientOptions<Schema extends SchemaDef> = Omit<ClientOptions<Schema>, 'dialect'> & {
+    provider?: 'sqlite' | 'postgresql';
+    schemaFile?: string;
+    dbName?: string;
+    usePrismaPush?: boolean;
+    extraSourceFiles?: Record<string, string>;
+    workDir?: string;
+    debug?: boolean;
+    dbFile?: string;
+};
+declare function createTestClient<Schema extends SchemaDef>(schema: Schema, options?: CreateTestClientOptions<Schema>): Promise<ClientContract<Schema>>;
+declare function createTestClient<Schema extends SchemaDef>(schema: string, options?: CreateTestClientOptions<Schema>): 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 generateTsSchema(schemaText: string, provider?: 'sqlite' | 'postgresql', dbUrl?: string, extraSourceFiles?: Record<string, string>): Promise<{
+declare function createTestProject(zmodelContent?: string): string;
+
+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;
+    schema: SchemaDef$1;
+    schemaLite: SchemaDef$1 | undefined;
 }>;
 declare function generateTsSchemaFromFile(filePath: string): Promise<{
+    model: _zenstackhq_language_ast.Model;
     workDir: string;
-    schema: SchemaDef;
+    schema: SchemaDef$1;
+    schemaLite: SchemaDef$1 | undefined;
 }>;
 declare function generateTsSchemaInPlace(schemaPath: string): Promise<{
     workDir: string;
-    schema: SchemaDef;
+    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 { createTestProject, generateTsSchema, generateTsSchemaFromFile, generateTsSchemaInPlace };
+export { type CreateTestClientOptions, createPolicyTestClient, createTestClient, createTestProject, generateTsSchema, generateTsSchemaFromFile, generateTsSchemaInPlace, getTestDbProvider, loadSchema, loadSchemaWithError, testLogger };

package/dist/index.d.ts

@@ -1,18 +1,46 @@
-import { SchemaDef } from '@zenstackhq/sdk/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/schema';
 
-declare function createTestProject(): string;
+declare function getTestDbProvider(): "sqlite" | "postgresql";
+type CreateTestClientOptions<Schema extends SchemaDef> = Omit<ClientOptions<Schema>, 'dialect'> & {
+    provider?: 'sqlite' | 'postgresql';
+    schemaFile?: string;
+    dbName?: string;
+    usePrismaPush?: boolean;
+    extraSourceFiles?: Record<string, string>;
+    workDir?: string;
+    debug?: boolean;
+    dbFile?: string;
+};
+declare function createTestClient<Schema extends SchemaDef>(schema: Schema, options?: CreateTestClientOptions<Schema>): Promise<ClientContract<Schema>>;
+declare function createTestClient<Schema extends SchemaDef>(schema: string, options?: CreateTestClientOptions<Schema>): 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 generateTsSchema(schemaText: string, provider?: 'sqlite' | 'postgresql', dbUrl?: string, extraSourceFiles?: Record<string, string>): Promise<{
+declare function createTestProject(zmodelContent?: string): string;
+
+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;
+    schema: SchemaDef$1;
+    schemaLite: SchemaDef$1 | undefined;
 }>;
 declare function generateTsSchemaFromFile(filePath: string): Promise<{
+    model: _zenstackhq_language_ast.Model;
     workDir: string;
-    schema: SchemaDef;
+    schema: SchemaDef$1;
+    schemaLite: SchemaDef$1 | undefined;
 }>;
 declare function generateTsSchemaInPlace(schemaPath: string): Promise<{
     workDir: string;
-    schema: SchemaDef;
+    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 { createTestProject, generateTsSchema, generateTsSchemaFromFile, generateTsSchemaInPlace };
+export { type CreateTestClientOptions, createPolicyTestClient, createTestClient, createTestProject, generateTsSchema, generateTsSchemaFromFile, generateTsSchemaInPlace, getTestDbProvider, loadSchema, loadSchemaWithError, testLogger };

package/dist/index.js

@@ -1,11 +1,31 @@
 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 { ZenStackClient } from "@zenstackhq/orm";
+import { PolicyPlugin } from "@zenstackhq/plugin-policy";
+import { PrismaSchemaGenerator } from "@zenstackhq/sdk";
+import SQLite from "better-sqlite3";
+import { PostgresDialect, SqliteDialect } from "kysely";
+import { execSync as execSync2 } from "child_process";
+import { createHash } from "crypto";
+import fs3 from "fs";
+import path3 from "path";
+import { Client as PGClient, Pool } from "pg";
+import { expect as expect2 } from "vitest";
 
 // src/project.ts
 import fs from "fs";
 import path from "path";
 import tmp from "tmp";
-function createTestProject() {
+function createTestProject(zmodelContent) {
   const { name: workDir } = tmp.dirSync({
     unsafeCleanup: true
   });
@@ -20,7 +40,7 @@ function createTestProject() {
   const zenstackPackages = [
     "language",
     "sdk",
-    "runtime",
+    "orm",
     "cli"
   ];
   fs.mkdirSync(path.join(workDir, "node_modules/@zenstackhq"));
@@ -45,18 +65,35 @@ function createTestProject() {
       "**/*.ts"
     ]
   }, null, 4));
+  if (zmodelContent) {
+    fs.writeFileSync(path.join(workDir, "schema.zmodel"), zmodelContent);
+  }
   return workDir;
 }
 __name(createTestProject, "createTestProject");
 
 // src/schema.ts
-import { loadDocument } from "@zenstackhq/language";
+import { invariant } from "@zenstackhq/common-helpers";
 import { TsSchemaGenerator } from "@zenstackhq/sdk";
-import { glob } from "glob";
 import { execSync } from "child_process";
+import crypto from "crypto";
 import fs2 from "fs";
+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 `
@@ -75,30 +112,40 @@ 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 pluginModelFiles = glob.sync(path2.resolve(__dirname, "../../runtime/src/plugins/**/plugin.zmodel"));
-  const result = await loadDocument(zmodelPath, pluginModelFiles);
+${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}.ts`);
+      const filePath = path2.resolve(workDir, !fileName.endsWith(".ts") ? `${fileName}.ts` : fileName);
       fs2.mkdirSync(path2.dirname(filePath), {
         recursive: true
       });
       fs2.writeFileSync(filePath, content);
     }
   }
-  return compileAndLoad(workDir);
+  return {
+    ...await compileAndLoad(workDir),
+    model: result.model
+  };
 }
 __name(generateTsSchema, "generateTsSchema");
 async function compileAndLoad(workDir) {
@@ -107,9 +154,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");
@@ -120,20 +173,361 @@ function generateTsSchemaFromFile(filePath) {
 __name(generateTsSchemaFromFile, "generateTsSchemaFromFile");
 async function generateTsSchemaInPlace(schemaPath) {
   const workDir = path2.dirname(schemaPath);
-  const pluginModelFiles = glob.sync(path2.resolve(__dirname, "../../runtime/src/plugins/**/plugin.zmodel"));
-  const result = await loadDocument(schemaPath, pluginModelFiles);
+  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");
+async function loadSchema(schema, additionalSchemas) {
+  if (!schema.includes("datasource ")) {
+    schema = `${makePrelude("sqlite")}
+
+${schema}`;
+  }
+  const tempDir = fs2.mkdtempSync(path2.join(os.tmpdir(), "zenstack-schema"));
+  const tempFile = path2.join(tempDir, `schema.zmodel`);
+  fs2.writeFileSync(tempFile, schema);
+  if (additionalSchemas) {
+    for (const [fileName, content] of Object.entries(additionalSchemas)) {
+      let name = fileName;
+      if (!name.endsWith(".zmodel")) {
+        name += ".zmodel";
+      }
+      const filePath = path2.join(tempDir, name);
+      fs2.writeFileSync(filePath, content);
+    }
+  }
+  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;
+}
+__name(loadSchema, "loadSchema");
+async function loadSchemaWithError(schema, error) {
+  if (!schema.includes("datasource ")) {
+    schema = `${makePrelude("sqlite")}
+
+${schema}`;
+  }
+  const tempFile = path2.join(os.tmpdir(), `zenstack-schema-${crypto.randomUUID()}.zmodel`);
+  fs2.writeFileSync(tempFile, schema);
+  const r = await loadDocumentWithPlugins(tempFile);
+  expect(r.success).toBe(false);
+  invariant(!r.success);
+  if (typeof error === "string") {
+    expect(r).toSatisfy((r2) => r2.errors.some((e) => e.toString().toLowerCase().includes(error.toLowerCase())), `Expected error message to include "${error}" but got: ${r.errors.map((e) => e.toString()).join(", ")}`);
+  } else {
+    expect(r).toSatisfy((r2) => r2.errors.some((e) => error.test(e)), `Expected error message to match "${error}" but got: ${r.errors.map((e) => e.toString()).join(", ")}`);
+  }
+}
+__name(loadSchemaWithError, "loadSchemaWithError");
+
+// src/client.ts
+function getTestDbProvider() {
+  const val = process.env["TEST_DB_PROVIDER"] ?? "sqlite";
+  if (![
+    "sqlite",
+    "postgresql"
+  ].includes(val)) {
+    throw new Error(`Invalid TEST_DB_PROVIDER value: ${val}`);
+  }
+  return val;
+}
+__name(getTestDbProvider, "getTestDbProvider");
+var TEST_PG_CONFIG = {
+  host: process.env["TEST_PG_HOST"] ?? "localhost",
+  port: process.env["TEST_PG_PORT"] ? parseInt(process.env["TEST_PG_PORT"]) : 5432,
+  user: process.env["TEST_PG_USER"] ?? "postgres",
+  password: process.env["TEST_PG_PASSWORD"] ?? "postgres"
+};
+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}`;
+  let model;
+  if (typeof schema === "string") {
+    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
+      }
+    };
+  } else {
+    _schema = {
+      ...schema,
+      provider: {
+        type: provider
+      }
+    };
+    workDir ??= createTestProject();
+    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}'
+}`);
+      }
+      fs3.writeFileSync(path3.join(workDir, "schema.zmodel"), schemaContent);
+    }
+  }
+  invariant2(workDir);
+  if (options?.debug) {
+    console.log(`Work directory: ${workDir}`);
+  }
+  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));
+  }
+  const { plugins, ...rest } = options ?? {};
+  const _options = {
+    ...rest
+  };
+  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") {
+    _options.dialect = new PostgresDialect({
+      pool: new Pool({
+        ...TEST_PG_CONFIG,
+        database: dbName
+      })
+    });
+  } else {
+    _options.dialect = new SqliteDialect({
+      database: new SQLite(path3.join(workDir, dbName))
+    });
+  }
+  let client = new ZenStackClient(_schema, _options);
+  if (!options?.usePrismaPush && !options?.dbFile) {
+    await client.$pushSchema();
+  }
+  if (plugins) {
+    for (const plugin of plugins) {
+      client = client.$use(plugin);
+    }
+  }
+  return client;
+}
+__name(createTestClient, "createTestClient");
+async function createPolicyTestClient(schema, options) {
+  return createTestClient(schema, {
+    ...options,
+    plugins: [
+      ...options?.plugins ?? [],
+      new PolicyPlugin()
+    ]
+  });
+}
+__name(createPolicyTestClient, "createPolicyTestClient");
+function testLogger(e) {
+  console.log(e.query.sql, e.query.parameters);
+}
+__name(testLogger, "testLogger");
+function getTestDbName(provider) {
+  if (provider === "sqlite") {
+    return "./test.db";
+  }
+  const testName = expect2.getState().currentTestName ?? "unnamed";
+  const testPath = expect2.getState().testPath ?? "";
+  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 { 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 expectErrorReason(err, errorReason) {
+  if (err instanceof ORMError && err.reason === errorReason) {
+    return {
+      message: /* @__PURE__ */ __name(() => "", "message"),
+      pass: true
+    };
+  } else {
+    return {
+      message: /* @__PURE__ */ __name(() => `expected ORMError of reason ${errorReason}, got ${err}`, "message"),
+      pass: false
+    };
+  }
+}
+__name(expectErrorReason, "expectErrorReason");
+function expectErrorMessages(expectedMessages, message) {
+  for (const m of expectedMessages) {
+    if (!message.toLowerCase().includes(m.toLowerCase())) {
+      return {
+        message: /* @__PURE__ */ __name(() => `expected message not found in error: ${m}, got message: ${message}`, "message"),
+        pass: false
+      };
+    }
+  }
+  return void 0;
+}
+__name(expectErrorMessages, "expectErrorMessages");
+expect3.extend({
+  async toResolveTruthy(received) {
+    if (!isPromise(received)) {
+      return {
+        message: /* @__PURE__ */ __name(() => "a promise is expected", "message"),
+        pass: false
+      };
+    }
+    const r = await received;
+    return {
+      pass: !!r,
+      message: /* @__PURE__ */ __name(() => `Expected promise to resolve to a truthy value, but got ${r}`, "message")
+    };
+  },
+  async toResolveFalsy(received) {
+    if (!isPromise(received)) {
+      return {
+        message: /* @__PURE__ */ __name(() => "a promise is expected", "message"),
+        pass: false
+      };
+    }
+    const r = await received;
+    return {
+      pass: !r,
+      message: /* @__PURE__ */ __name(() => `Expected promise to resolve to a falsy value, but got ${r}`, "message")
+    };
+  },
+  async toResolveNull(received) {
+    if (!isPromise(received)) {
+      return {
+        message: /* @__PURE__ */ __name(() => "a promise is expected", "message"),
+        pass: false
+      };
+    }
+    const r = await received;
+    return {
+      pass: r === null,
+      message: /* @__PURE__ */ __name(() => `Expected promise to resolve to a null value, but got ${r}`, "message")
+    };
+  },
+  async toResolveWithLength(received, length) {
+    const r = await received;
+    return {
+      pass: Array.isArray(r) && r.length === length,
+      message: /* @__PURE__ */ __name(() => `Expected promise to resolve with an array with length ${length}, but got ${r}`, "message")
+    };
+  },
+  async toBeRejectedNotFound(received) {
+    if (!isPromise(received)) {
+      return {
+        message: /* @__PURE__ */ __name(() => "a promise is expected", "message"),
+        pass: false
+      };
+    }
+    try {
+      await received;
+    } catch (err) {
+      return expectErrorReason(err, ORMErrorReason.NOT_FOUND);
+    }
+    return {
+      message: /* @__PURE__ */ __name(() => `expected NotFoundError, got no error`, "message"),
+      pass: false
+    };
+  },
+  async toBeRejectedByPolicy(received, expectedMessages) {
+    if (!isPromise(received)) {
+      return {
+        message: /* @__PURE__ */ __name(() => "a promise is expected", "message"),
+        pass: false
+      };
+    }
+    try {
+      await received;
+    } catch (err) {
+      if (expectedMessages && err instanceof ORMError && err.reason === ORMErrorReason.REJECTED_BY_POLICY) {
+        const r = expectErrorMessages(expectedMessages, err.message || "");
+        if (r) {
+          return r;
+        }
+      }
+      return expectErrorReason(err, ORMErrorReason.REJECTED_BY_POLICY);
+    }
+    return {
+      message: /* @__PURE__ */ __name(() => `expected PolicyError, got no error`, "message"),
+      pass: false
+    };
+  },
+  async toBeRejectedByValidation(received, expectedMessages) {
+    if (!isPromise(received)) {
+      return {
+        message: /* @__PURE__ */ __name(() => "a promise is expected", "message"),
+        pass: false
+      };
+    }
+    try {
+      await received;
+    } catch (err) {
+      if (expectedMessages && err instanceof ORMError && err.reason === ORMErrorReason.INVALID_INPUT) {
+        const r = expectErrorMessages(expectedMessages, err.message || "");
+        if (r) {
+          return r;
+        }
+      }
+      return expectErrorReason(err, ORMErrorReason.INVALID_INPUT);
+    }
+    return {
+      message: /* @__PURE__ */ __name(() => `expected InputValidationError, got no error`, "message"),
+      pass: false
+    };
+  }
+});
 export {
+  createPolicyTestClient,
+  createTestClient,
   createTestProject,
   generateTsSchema,
   generateTsSchemaFromFile,
-  generateTsSchemaInPlace
+  generateTsSchemaInPlace,
+  getTestDbProvider,
+  loadSchema,
+  loadSchemaWithError,
+  testLogger
 };
 //# sourceMappingURL=index.js.map