@zenstackhq/testtools 3.5.6 → 3.6.1

package/dist/index.cjs

@@ -1,655 +1,482 @@
-"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  TEST_MYSQL_CONFIG: () => TEST_MYSQL_CONFIG,
-  TEST_MYSQL_URL: () => TEST_MYSQL_URL,
-  TEST_PG_CONFIG: () => TEST_PG_CONFIG,
-  TEST_PG_URL: () => TEST_PG_URL,
-  createPolicyTestClient: () => createPolicyTestClient,
-  createTestClient: () => createTestClient,
-  createTestProject: () => createTestProject,
-  generateTsSchema: () => generateTsSchema,
-  generateTsSchemaFromFile: () => generateTsSchemaFromFile,
-  generateTsSchemaInPlace: () => generateTsSchemaInPlace,
-  getTestDbProvider: () => getTestDbProvider,
-  loadSchema: () => loadSchema,
-  loadSchemaWithError: () => loadSchemaWithError,
-  testLogger: () => testLogger
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/client.ts
-var import_common_helpers2 = require("@zenstackhq/common-helpers");
-var import_orm = require("@zenstackhq/orm");
-var import_plugin_policy = require("@zenstackhq/plugin-policy");
-var import_sdk2 = require("@zenstackhq/sdk");
-var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
-var import_glob = require("glob");
-var import_kysely = require("kysely");
-var import_mysql2 = require("mysql2");
-var import_node_child_process2 = require("child_process");
-var import_node_crypto2 = require("crypto");
-var import_node_fs3 = __toESM(require("fs"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
-var import_pg = require("pg");
-var import_ts_pattern2 = require("ts-pattern");
-var import_vitest2 = require("vitest");
-
-// src/project.ts
-var import_node_fs = __toESM(require("fs"), 1);
-var import_node_path = __toESM(require("path"), 1);
-var import_tmp = __toESM(require("tmp"), 1);
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _zenstackhq_common_helpers = require("@zenstackhq/common-helpers");
+let _zenstackhq_orm = require("@zenstackhq/orm");
+let _zenstackhq_plugin_policy = require("@zenstackhq/plugin-policy");
+let _zenstackhq_sdk = require("@zenstackhq/sdk");
+let better_sqlite3 = require("better-sqlite3");
+better_sqlite3 = __toESM(better_sqlite3, 1);
+let glob = require("glob");
+let kysely = require("kysely");
+let mysql2 = require("mysql2");
+let node_child_process = require("node:child_process");
+let node_crypto = require("node:crypto");
+node_crypto = __toESM(node_crypto, 1);
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let pg = require("pg");
+let ts_pattern = require("ts-pattern");
+let vitest = require("vitest");
+let tmp = require("tmp");
+tmp = __toESM(tmp, 1);
+let node_os = require("node:os");
+node_os = __toESM(node_os, 1);
+let _zenstackhq_language = require("@zenstackhq/language");
+//#region src/project.ts
 function createTestProject(zmodelContent) {
-  const { name: workDir } = import_tmp.default.dirSync({
-    unsafeCleanup: true
-  });
-  import_node_fs.default.mkdirSync(import_node_path.default.join(workDir, "node_modules"));
-  const nodeModules = import_node_fs.default.readdirSync(import_node_path.default.join(__dirname, "../node_modules"));
-  for (const entry of nodeModules) {
-    if (entry.startsWith("@zenstackhq")) {
-      continue;
-    }
-    import_node_fs.default.symlinkSync(import_node_path.default.join(__dirname, "../node_modules", entry), import_node_path.default.join(workDir, "node_modules", entry), "dir");
-  }
-  const zenstackPackages = [
-    "language",
-    "sdk",
-    "schema",
-    "orm",
-    "cli"
-  ];
-  import_node_fs.default.mkdirSync(import_node_path.default.join(workDir, "node_modules/@zenstackhq"));
-  for (const pkg of zenstackPackages) {
-    import_node_fs.default.symlinkSync(import_node_path.default.join(__dirname, `../../${pkg}`), import_node_path.default.join(workDir, `node_modules/@zenstackhq/${pkg}`), "dir");
-  }
-  import_node_fs.default.writeFileSync(import_node_path.default.join(workDir, "package.json"), JSON.stringify({
-    name: "test",
-    version: "1.0.0",
-    type: "module"
-  }, null, 4));
-  import_node_fs.default.writeFileSync(import_node_path.default.join(workDir, "tsconfig.json"), JSON.stringify({
-    compilerOptions: {
-      module: "ESNext",
-      target: "ESNext",
-      moduleResolution: "Bundler",
-      esModuleInterop: true,
-      skipLibCheck: true,
-      strict: true
-    },
-    include: [
-      "**/*.ts"
-    ]
-  }, null, 4));
-  if (zmodelContent) {
-    import_node_fs.default.writeFileSync(import_node_path.default.join(workDir, "schema.zmodel"), zmodelContent);
-  }
-  return workDir;
+	const { name: workDir } = tmp.default.dirSync({ unsafeCleanup: true });
+	node_fs.default.mkdirSync(node_path.default.join(workDir, "node_modules"));
+	const nodeModules = node_fs.default.readdirSync(node_path.default.join(__dirname, "../node_modules"));
+	for (const entry of nodeModules) {
+		if (entry.startsWith("@zenstackhq")) continue;
+		node_fs.default.symlinkSync(node_path.default.join(__dirname, "../node_modules", entry), node_path.default.join(workDir, "node_modules", entry), "dir");
+	}
+	const zenstackPackages = [
+		"language",
+		"sdk",
+		"schema",
+		"orm",
+		"cli"
+	];
+	node_fs.default.mkdirSync(node_path.default.join(workDir, "node_modules/@zenstackhq"));
+	for (const pkg of zenstackPackages) node_fs.default.symlinkSync(node_path.default.join(__dirname, `../../${pkg}`), node_path.default.join(workDir, `node_modules/@zenstackhq/${pkg}`), "dir");
+	node_fs.default.writeFileSync(node_path.default.join(workDir, "package.json"), JSON.stringify({
+		name: "test",
+		version: "1.0.0",
+		type: "module"
+	}, null, 4));
+	node_fs.default.writeFileSync(node_path.default.join(workDir, "tsconfig.json"), JSON.stringify({
+		compilerOptions: {
+			module: "ESNext",
+			target: "ESNext",
+			moduleResolution: "Bundler",
+			esModuleInterop: true,
+			skipLibCheck: true,
+			strict: true
+		},
+		include: ["**/*.ts"]
+	}, null, 4));
+	if (zmodelContent) node_fs.default.writeFileSync(node_path.default.join(workDir, "schema.zmodel"), zmodelContent);
+	return workDir;
 }
-__name(createTestProject, "createTestProject");
-
-// src/schema.ts
-var import_common_helpers = require("@zenstackhq/common-helpers");
-var import_sdk = require("@zenstackhq/sdk");
-var import_node_child_process = require("child_process");
-var import_node_crypto = __toESM(require("crypto"), 1);
-var import_node_fs2 = __toESM(require("fs"), 1);
-var import_node_os = __toESM(require("os"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
-var import_ts_pattern = require("ts-pattern");
-var import_vitest = require("vitest");
-
-// src/utils.ts
-var import_language = require("@zenstackhq/language");
+//#endregion
+//#region src/utils.ts
 function loadDocumentWithPlugins(filePath) {
-  const pluginModelFiles = [
-    require.resolve("@zenstackhq/plugin-policy/plugin.zmodel")
-  ];
-  return (0, import_language.loadDocument)(filePath, pluginModelFiles);
+	return (0, _zenstackhq_language.loadDocument)(filePath, [require.resolve("@zenstackhq/plugin-policy/plugin.zmodel")]);
 }
-__name(loadDocumentWithPlugins, "loadDocumentWithPlugins");
-
-// src/schema.ts
+//#endregion
+//#region src/schema.ts
 function makePrelude(provider, dbUrl) {
-  return (0, import_ts_pattern.match)(provider).with("sqlite", () => {
-    return `
+	return (0, ts_pattern.match)(provider).with("sqlite", () => {
+		return `
 datasource db {
     provider = 'sqlite'
     url = '${dbUrl ?? "file:./test.db"}'
 }
 `;
-  }).with("postgresql", () => {
-    return `
+	}).with("postgresql", () => {
+		return `
 datasource db {
     provider = 'postgresql'
     url = '${dbUrl ?? "postgres://postgres:postgres@localhost:5432/db"}'
 }
 `;
-  }).with("mysql", () => {
-    return `
+	}).with("mysql", () => {
+		return `
 datasource db {
     provider = 'mysql'
     url = '${dbUrl ?? "mysql://root:mysql@localhost:3306/db"}'
 }
 `;
-  }).exhaustive();
+	}).exhaustive();
 }
-__name(makePrelude, "makePrelude");
 function replacePlaceholders(schemaText, provider, dbUrl) {
-  const url = dbUrl ?? (provider === "sqlite" ? "file:./test.db" : provider === "mysql" ? "mysql://root:mysql@localhost:3306/db" : "postgres://postgres:postgres@localhost:5432/db");
-  return schemaText.replace(/\$DB_URL/g, url).replace(/\$PROVIDER/g, provider);
+	const url = dbUrl ?? (provider === "sqlite" ? "file:./test.db" : provider === "mysql" ? "mysql://root:mysql@localhost:3306/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, extraZModelFiles) {
-  const workDir = createTestProject();
-  const zmodelPath = import_node_path2.default.join(workDir, "schema.zmodel");
-  const noPrelude = schemaText.includes("datasource ");
-  import_node_fs2.default.writeFileSync(zmodelPath, `${noPrelude ? "" : makePrelude(provider, dbUrl)}
-
-${replacePlaceholders(schemaText, provider, dbUrl)}`);
-  if (extraZModelFiles) {
-    for (const [fileName, content] of Object.entries(extraZModelFiles)) {
-      let name = fileName;
-      if (!name.endsWith(".zmodel")) {
-        name += ".zmodel";
-      }
-      const filePath = import_node_path2.default.join(workDir, name);
-      import_node_fs2.default.mkdirSync(import_node_path2.default.dirname(filePath), {
-        recursive: true
-      });
-      import_node_fs2.default.writeFileSync(filePath, content);
-    }
-  }
-  const result = await loadDocumentWithPlugins(zmodelPath);
-  if (!result.success) {
-    throw new Error(`Failed to load schema from ${zmodelPath}: ${result.errors}`);
-  }
-  const generator = new import_sdk.TsSchemaGenerator();
-  await generator.generate(result.model, {
-    outDir: workDir,
-    lite: withLiteSchema
-  });
-  if (extraSourceFiles) {
-    for (const [fileName, content] of Object.entries(extraSourceFiles)) {
-      const filePath = import_node_path2.default.resolve(workDir, !fileName.endsWith(".ts") ? `${fileName}.ts` : fileName);
-      import_node_fs2.default.mkdirSync(import_node_path2.default.dirname(filePath), {
-        recursive: true
-      });
-      import_node_fs2.default.writeFileSync(filePath, content);
-    }
-  }
-  return {
-    ...await compileAndLoad(workDir),
-    model: result.model
-  };
+	const workDir = createTestProject();
+	const zmodelPath = node_path.default.join(workDir, "schema.zmodel");
+	const noPrelude = schemaText.includes("datasource ");
+	node_fs.default.writeFileSync(zmodelPath, `${noPrelude ? "" : makePrelude(provider, dbUrl)}\n\n${replacePlaceholders(schemaText, provider, dbUrl)}`);
+	if (extraZModelFiles) for (const [fileName, content] of Object.entries(extraZModelFiles)) {
+		let name = fileName;
+		if (!name.endsWith(".zmodel")) name += ".zmodel";
+		const filePath = node_path.default.join(workDir, name);
+		node_fs.default.mkdirSync(node_path.default.dirname(filePath), { recursive: true });
+		node_fs.default.writeFileSync(filePath, content);
+	}
+	const result = await loadDocumentWithPlugins(zmodelPath);
+	if (!result.success) throw new Error(`Failed to load schema from ${zmodelPath}: ${result.errors}`);
+	await new _zenstackhq_sdk.TsSchemaGenerator().generate(result.model, {
+		outDir: workDir,
+		lite: withLiteSchema
+	});
+	if (extraSourceFiles) for (const [fileName, content] of Object.entries(extraSourceFiles)) {
+		const filePath = node_path.default.resolve(workDir, !fileName.endsWith(".ts") ? `${fileName}.ts` : fileName);
+		node_fs.default.mkdirSync(node_path.default.dirname(filePath), { recursive: true });
+		node_fs.default.writeFileSync(filePath, content);
+	}
+	return {
+		...await compileAndLoad(workDir),
+		model: result.model
+	};
 }
-__name(generateTsSchema, "generateTsSchema");
 async function compileAndLoad(workDir) {
-  (0, import_node_child_process.execSync)("npx tsc", {
-    cwd: workDir,
-    stdio: "inherit"
-  });
-  const module2 = await import(import_node_path2.default.join(workDir, "schema.js"));
-  let moduleLite;
-  try {
-    moduleLite = await import(import_node_path2.default.join(workDir, "schema-lite.js"));
-  } catch {
-  }
-  return {
-    workDir,
-    schema: module2.schema,
-    schemaLite: moduleLite?.schema
-  };
+	(0, node_child_process.execSync)("npx tsc", {
+		cwd: workDir,
+		stdio: "inherit"
+	});
+	const module = await import(node_path.default.join(workDir, "schema.js"));
+	let moduleLite;
+	try {
+		moduleLite = await import(node_path.default.join(workDir, "schema-lite.js"));
+	} catch {}
+	return {
+		workDir,
+		schema: module.schema,
+		schemaLite: moduleLite?.schema
+	};
 }
-__name(compileAndLoad, "compileAndLoad");
 function generateTsSchemaFromFile(filePath) {
-  const schemaText = import_node_fs2.default.readFileSync(filePath, "utf8");
-  return generateTsSchema(schemaText);
+	return generateTsSchema(node_fs.default.readFileSync(filePath, "utf8"));
 }
-__name(generateTsSchemaFromFile, "generateTsSchemaFromFile");
 async function generateTsSchemaInPlace(schemaPath) {
-  const workDir = import_node_path2.default.dirname(schemaPath);
-  const result = await loadDocumentWithPlugins(schemaPath);
-  if (!result.success) {
-    throw new Error(`Failed to load schema from ${schemaPath}: ${result.errors}`);
-  }
-  const generator = new import_sdk.TsSchemaGenerator();
-  await generator.generate(result.model, {
-    outDir: workDir
-  });
-  return compileAndLoad(workDir);
+	const workDir = node_path.default.dirname(schemaPath);
+	const result = await loadDocumentWithPlugins(schemaPath);
+	if (!result.success) throw new Error(`Failed to load schema from ${schemaPath}: ${result.errors}`);
+	await new _zenstackhq_sdk.TsSchemaGenerator().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 = import_node_fs2.default.mkdtempSync(import_node_path2.default.join(import_node_os.default.tmpdir(), "zenstack-schema"));
-  const tempFile = import_node_path2.default.join(tempDir, `schema.zmodel`);
-  import_node_fs2.default.writeFileSync(tempFile, schema);
-  if (additionalSchemas) {
-    for (const [fileName, content] of Object.entries(additionalSchemas)) {
-      let name = fileName;
-      if (!name.endsWith(".zmodel")) {
-        name += ".zmodel";
-      }
-      const filePath = import_node_path2.default.join(tempDir, name);
-      import_node_fs2.default.writeFileSync(filePath, content);
-    }
-  }
-  const r = await loadDocumentWithPlugins(tempFile);
-  (0, import_vitest.expect)(r).toSatisfy((r2) => r2.success, `Failed to load schema: ${r.errors?.map((e) => e.toString()).join(", ")}`);
-  (0, import_common_helpers.invariant)(r.success);
-  return r.model;
+	if (!schema.includes("datasource ")) schema = `${makePrelude("sqlite")}\n\n${schema}`;
+	const tempDir = node_fs.default.mkdtempSync(node_path.default.join(node_os.default.tmpdir(), "zenstack-schema"));
+	const tempFile = node_path.default.join(tempDir, `schema.zmodel`);
+	node_fs.default.writeFileSync(tempFile, schema);
+	if (additionalSchemas) for (const [fileName, content] of Object.entries(additionalSchemas)) {
+		let name = fileName;
+		if (!name.endsWith(".zmodel")) name += ".zmodel";
+		const filePath = node_path.default.join(tempDir, name);
+		node_fs.default.writeFileSync(filePath, content);
+	}
+	const r = await loadDocumentWithPlugins(tempFile);
+	(0, vitest.expect)(r).toSatisfy((r) => r.success, `Failed to load schema: ${r.errors?.map((e) => e.toString()).join(", ")}`);
+	(0, _zenstackhq_common_helpers.invariant)(r.success);
+	return r.model;
 }
-__name(loadSchema, "loadSchema");
 async function loadSchemaWithError(schema, error) {
-  if (!schema.includes("datasource ")) {
-    schema = `${makePrelude("sqlite")}
-
-${schema}`;
-  }
-  const tempFile = import_node_path2.default.join(import_node_os.default.tmpdir(), `zenstack-schema-${import_node_crypto.default.randomUUID()}.zmodel`);
-  import_node_fs2.default.writeFileSync(tempFile, schema);
-  const r = await loadDocumentWithPlugins(tempFile);
-  (0, import_vitest.expect)(r.success).toBe(false);
-  (0, import_common_helpers.invariant)(!r.success);
-  if (typeof error === "string") {
-    (0, import_vitest.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 {
-    (0, import_vitest.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(", ")}`);
-  }
+	if (!schema.includes("datasource ")) schema = `${makePrelude("sqlite")}\n\n${schema}`;
+	const tempFile = node_path.default.join(node_os.default.tmpdir(), `zenstack-schema-${node_crypto.default.randomUUID()}.zmodel`);
+	node_fs.default.writeFileSync(tempFile, schema);
+	const r = await loadDocumentWithPlugins(tempFile);
+	(0, vitest.expect)(r.success).toBe(false);
+	(0, _zenstackhq_common_helpers.invariant)(!r.success);
+	if (typeof error === "string") (0, vitest.expect)(r).toSatisfy((r) => r.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 (0, vitest.expect)(r).toSatisfy((r) => r.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
+//#endregion
+//#region src/client.ts
 function getTestDbProvider() {
-  const val = process.env["TEST_DB_PROVIDER"] ?? "sqlite";
-  if (![
-    "sqlite",
-    "postgresql",
-    "mysql"
-  ].includes(val)) {
-    throw new Error(`Invalid TEST_DB_PROVIDER value: ${val}`);
-  }
-  return val;
+	const val = process.env["TEST_DB_PROVIDER"] ?? "sqlite";
+	if (![
+		"sqlite",
+		"postgresql",
+		"mysql"
+	].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"
+const 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"
 };
-var TEST_PG_URL = `postgres://${TEST_PG_CONFIG.user}:${TEST_PG_CONFIG.password}@${TEST_PG_CONFIG.host}:${TEST_PG_CONFIG.port}`;
-var TEST_MYSQL_CONFIG = {
-  host: process.env["TEST_MYSQL_HOST"] ?? "localhost",
-  port: process.env["TEST_MYSQL_PORT"] ? parseInt(process.env["TEST_MYSQL_PORT"]) : 3306,
-  user: process.env["TEST_MYSQL_USER"] ?? "root",
-  password: process.env["TEST_MYSQL_PASSWORD"] ?? "mysql",
-  timezone: "Z"
+const TEST_PG_URL = `postgres://${TEST_PG_CONFIG.user}:${TEST_PG_CONFIG.password}@${TEST_PG_CONFIG.host}:${TEST_PG_CONFIG.port}`;
+const TEST_MYSQL_CONFIG = {
+	host: process.env["TEST_MYSQL_HOST"] ?? "localhost",
+	port: process.env["TEST_MYSQL_PORT"] ? parseInt(process.env["TEST_MYSQL_PORT"]) : 3306,
+	user: process.env["TEST_MYSQL_USER"] ?? "root",
+	password: process.env["TEST_MYSQL_PASSWORD"] ?? "mysql",
+	timezone: "Z"
 };
-var TEST_MYSQL_URL = `mysql://${TEST_MYSQL_CONFIG.user}:${TEST_MYSQL_CONFIG.password}@${TEST_MYSQL_CONFIG.host}:${TEST_MYSQL_CONFIG.port}`;
+const TEST_MYSQL_URL = `mysql://${TEST_MYSQL_CONFIG.user}:${TEST_MYSQL_CONFIG.password}@${TEST_MYSQL_CONFIG.host}:${TEST_MYSQL_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 = (0, import_ts_pattern2.match)(provider).with("sqlite", () => `file:${dbName}`).with("mysql", () => `${TEST_MYSQL_URL}/${dbName}`).with("postgresql", () => `${TEST_PG_URL}/${dbName}`).exhaustive();
-  let model;
-  if (typeof schema === "string") {
-    const generated = await generateTsSchema(schema, provider, dbUrl, options?.extraSourceFiles, void 0, options?.extraZModelFiles);
-    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 = import_node_fs3.default.readFileSync(options.schemaFile, "utf-8");
-      if (dbUrl) {
-        schemaContent = schemaContent.replace(/datasource\s+db\s*{[^}]*}/m, `datasource db {
+	let workDir = options?.workDir;
+	let _schema;
+	const provider = options?.provider ?? getTestDbProvider() ?? "sqlite";
+	const dbName = options?.dbName ?? getTestDbName(provider);
+	const dbUrl = (0, ts_pattern.match)(provider).with("sqlite", () => `file:${dbName}`).with("mysql", () => `${TEST_MYSQL_URL}/${dbName}`).with("postgresql", () => `${TEST_PG_URL}/${dbName}`).exhaustive();
+	let model;
+	if (typeof schema === "string") {
+		const generated = await generateTsSchema(schema, provider, dbUrl, options?.extraSourceFiles, void 0, options?.extraZModelFiles);
+		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 = node_fs.default.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(", ")}]` : ""}
 }`);
-      }
-      import_node_fs3.default.writeFileSync(import_node_path3.default.join(workDir, "schema.zmodel"), schemaContent);
-    }
-  }
-  (0, import_common_helpers2.invariant)(workDir);
-  const { plugins, ...rest } = options ?? {};
-  const _options = {
-    ...rest
-  };
-  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");
-    }
-    import_node_fs3.default.copyFileSync(options.dbFile, import_node_path3.default.join(workDir, dbName));
-  }
-  if (options?.copyFiles) {
-    const state = import_vitest2.expect.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 = import_glob.glob.sync(globPattern, {
-        cwd: import_node_path3.default.dirname(currentTestPath)
-      });
-      for (const file of files) {
-        const src = import_node_path3.default.resolve(import_node_path3.default.dirname(currentTestPath), file);
-        const dest = import_node_path3.default.resolve(workDir, destination, import_node_path3.default.basename(file));
-        import_node_fs3.default.mkdirSync(import_node_path3.default.dirname(dest), {
-          recursive: true
-        });
-        import_node_fs3.default.copyFileSync(src, dest);
-      }
-    }
-  }
-  if (!options?.dbFile) {
-    if (options?.usePrismaPush) {
-      (0, import_common_helpers2.invariant)(typeof schema === "string" || options?.schemaFile, "a schema file must be provided when using prisma db push");
-      if (!model) {
-        const r = await loadDocumentWithPlugins(import_node_path3.default.join(workDir, "schema.zmodel"));
-        if (!r.success) {
-          throw new Error(r.errors.join("\n"));
-        }
-        model = r.model;
-      }
-      const prismaSchema = new import_sdk2.PrismaSchemaGenerator(model);
-      const prismaSchemaText = await prismaSchema.generate();
-      import_node_fs3.default.writeFileSync(import_node_path3.default.resolve(workDir, "schema.prisma"), prismaSchemaText);
-      (0, import_node_child_process2.execSync)("npx prisma db push --schema ./schema.prisma --skip-generate --force-reset", {
-        cwd: workDir,
-        stdio: options.debug ? "inherit" : "ignore",
-        env: {
-          ...process.env,
-          PRISMA_USER_CONSENT_FOR_DANGEROUS_AI_ACTION: "true"
-        }
-      });
-    } else {
-      await prepareDatabase(provider, dbName);
-    }
-  }
-  _options.dialect = createDialect(provider, dbName, workDir);
-  let client = new import_orm.ZenStackClient(_schema, _options);
-  if (!options?.usePrismaPush && !options?.dbFile) {
-    await client.$pushSchema();
-  }
-  if (plugins) {
-    for (const plugin of plugins) {
-      client = client.$use(plugin);
-    }
-  }
-  return client;
+			node_fs.default.writeFileSync(node_path.default.join(workDir, "schema.zmodel"), schemaContent);
+		}
+	}
+	(0, _zenstackhq_common_helpers.invariant)(workDir);
+	const { plugins, ...rest } = options ?? {};
+	const _options = { ...rest };
+	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");
+		node_fs.default.copyFileSync(options.dbFile, node_path.default.join(workDir, dbName));
+	}
+	if (options?.copyFiles) {
+		const currentTestPath = vitest.expect.getState().testPath;
+		if (!currentTestPath) throw new Error("Unable to determine current test file path");
+		for (const { globPattern, destination } of options.copyFiles) {
+			const files = glob.glob.sync(globPattern, { cwd: node_path.default.dirname(currentTestPath) });
+			for (const file of files) {
+				const src = node_path.default.resolve(node_path.default.dirname(currentTestPath), file);
+				const dest = node_path.default.resolve(workDir, destination, node_path.default.basename(file));
+				node_fs.default.mkdirSync(node_path.default.dirname(dest), { recursive: true });
+				node_fs.default.copyFileSync(src, dest);
+			}
+		}
+	}
+	if (!options?.dbFile) if (options?.usePrismaPush) {
+		(0, _zenstackhq_common_helpers.invariant)(typeof schema === "string" || options?.schemaFile, "a schema file must be provided when using prisma db push");
+		if (!model) {
+			const r = await loadDocumentWithPlugins(node_path.default.join(workDir, "schema.zmodel"));
+			if (!r.success) throw new Error(r.errors.join("\n"));
+			model = r.model;
+		}
+		const prismaSchemaText = await new _zenstackhq_sdk.PrismaSchemaGenerator(model).generate();
+		node_fs.default.writeFileSync(node_path.default.resolve(workDir, "schema.prisma"), prismaSchemaText);
+		(0, node_child_process.execSync)("npx prisma db push --schema ./schema.prisma --skip-generate --force-reset", {
+			cwd: workDir,
+			stdio: options.debug ? "inherit" : "ignore",
+			env: {
+				...process.env,
+				PRISMA_USER_CONSENT_FOR_DANGEROUS_AI_ACTION: "true"
+			}
+		});
+	} else await prepareDatabase(provider, dbName);
+	_options.dialect = createDialect(provider, dbName, workDir);
+	let client = new _zenstackhq_orm.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");
 function createDialect(provider, dbName, workDir) {
-  return (0, import_ts_pattern2.match)(provider).with("postgresql", () => new import_kysely.PostgresDialect({
-    pool: new import_pg.Pool({
-      ...TEST_PG_CONFIG,
-      database: dbName
-    })
-  })).with("mysql", () => new import_kysely.MysqlDialect({
-    pool: (0, import_mysql2.createPool)({
-      ...TEST_MYSQL_CONFIG,
-      database: dbName
-    })
-  })).with("sqlite", () => new import_kysely.SqliteDialect({
-    database: new import_better_sqlite3.default(import_node_path3.default.join(workDir, dbName))
-  })).exhaustive();
+	return (0, ts_pattern.match)(provider).with("postgresql", () => new kysely.PostgresDialect({ pool: new pg.Pool({
+		...TEST_PG_CONFIG,
+		database: dbName
+	}) })).with("mysql", () => new kysely.MysqlDialect({ pool: (0, mysql2.createPool)({
+		...TEST_MYSQL_CONFIG,
+		database: dbName
+	}) })).with("sqlite", () => new kysely.SqliteDialect({ database: new better_sqlite3.default(node_path.default.join(workDir, dbName)) })).exhaustive();
 }
-__name(createDialect, "createDialect");
 async function prepareDatabase(provider, dbName) {
-  if (provider === "postgresql") {
-    (0, import_common_helpers2.invariant)(dbName, "dbName is required");
-    const pgClient = new import_pg.Client(TEST_PG_CONFIG);
-    await pgClient.connect();
-    await pgClient.query(`DROP DATABASE IF EXISTS "${dbName}"`);
-    await pgClient.query(`CREATE DATABASE "${dbName}"`);
-    await pgClient.end();
-  } else if (provider === "mysql") {
-    (0, import_common_helpers2.invariant)(dbName, "dbName is required");
-    const mysqlPool = (0, import_mysql2.createPool)(TEST_MYSQL_CONFIG);
-    await mysqlPool.promise().query(`DROP DATABASE IF EXISTS \`${dbName}\``);
-    await mysqlPool.promise().query(`CREATE DATABASE \`${dbName}\``);
-    await mysqlPool.promise().end();
-  }
+	if (provider === "postgresql") {
+		(0, _zenstackhq_common_helpers.invariant)(dbName, "dbName is required");
+		const pgClient = new pg.Client(TEST_PG_CONFIG);
+		await pgClient.connect();
+		await pgClient.query(`DROP DATABASE IF EXISTS "${dbName}"`);
+		await pgClient.query(`CREATE DATABASE "${dbName}"`);
+		await pgClient.end();
+	} else if (provider === "mysql") {
+		(0, _zenstackhq_common_helpers.invariant)(dbName, "dbName is required");
+		const mysqlPool = (0, mysql2.createPool)(TEST_MYSQL_CONFIG);
+		await mysqlPool.promise().query(`DROP DATABASE IF EXISTS \`${dbName}\``);
+		await mysqlPool.promise().query(`CREATE DATABASE \`${dbName}\``);
+		await mysqlPool.promise().end();
+	}
 }
-__name(prepareDatabase, "prepareDatabase");
 async function createPolicyTestClient(schema, options) {
-  return createTestClient(schema, {
-    ...options,
-    plugins: [
-      ...options?.plugins ?? [],
-      new import_plugin_policy.PolicyPlugin()
-    ]
-  });
+	return createTestClient(schema, {
+		...options,
+		plugins: [...options?.plugins ?? [], new _zenstackhq_plugin_policy.PolicyPlugin()]
+	});
 }
-__name(createPolicyTestClient, "createPolicyTestClient");
 function testLogger(e) {
-  console.log(e.query.sql, e.query.parameters);
+	console.log(e.query.sql, e.query.parameters);
 }
-__name(testLogger, "testLogger");
 function getTestDbName(provider) {
-  if (provider === "sqlite") {
-    return "./test.db";
-  }
-  const testName = import_vitest2.expect.getState().currentTestName ?? "unnamed";
-  const testPath = import_vitest2.expect.getState().testPath ?? "";
-  const digest = (0, import_node_crypto2.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);
+	if (provider === "sqlite") return "./test.db";
+	const testName = vitest.expect.getState().currentTestName ?? "unnamed";
+	const testPath = vitest.expect.getState().testPath ?? "";
+	const digest = (0, node_crypto.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
-var import_orm2 = require("@zenstackhq/orm");
-var import_vitest3 = require("vitest");
+//#endregion
+//#region src/vitest-ext.ts
 function isPromise(value) {
-  return typeof value.then === "function" && typeof value.catch === "function";
+	return typeof value.then === "function" && typeof value.catch === "function";
 }
-__name(isPromise, "isPromise");
 function expectErrorReason(err, errorReason) {
-  if (err instanceof import_orm2.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
-    };
-  }
+	if (err instanceof _zenstackhq_orm.ORMError && err.reason === errorReason) return {
+		message: () => "",
+		pass: true
+	};
+	else return {
+		message: () => `expected ORMError of reason ${errorReason}, got ${err}`,
+		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;
+	for (const m of expectedMessages) if (!message.toLowerCase().includes(m.toLowerCase())) return {
+		message: () => `expected message not found in error: ${m}, got message: ${message}`,
+		pass: false
+	};
 }
-__name(expectErrorMessages, "expectErrorMessages");
-import_vitest3.expect.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, import_orm2.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 import_orm2.ORMError && err.reason === import_orm2.ORMErrorReason.REJECTED_BY_POLICY) {
-        const r = expectErrorMessages(expectedMessages, err.message || "");
-        if (r) {
-          return r;
-        }
-      }
-      return expectErrorReason(err, import_orm2.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 import_orm2.ORMError && err.reason === import_orm2.ORMErrorReason.INVALID_INPUT) {
-        const r = expectErrorMessages(expectedMessages, err.message || "");
-        if (r) {
-          return r;
-        }
-      }
-      return expectErrorReason(err, import_orm2.ORMErrorReason.INVALID_INPUT);
-    }
-    return {
-      message: /* @__PURE__ */ __name(() => `expected InputValidationError, got no error`, "message"),
-      pass: false
-    };
-  }
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  TEST_MYSQL_CONFIG,
-  TEST_MYSQL_URL,
-  TEST_PG_CONFIG,
-  TEST_PG_URL,
-  createPolicyTestClient,
-  createTestClient,
-  createTestProject,
-  generateTsSchema,
-  generateTsSchemaFromFile,
-  generateTsSchemaInPlace,
-  getTestDbProvider,
-  loadSchema,
-  loadSchemaWithError,
-  testLogger
+vitest.expect.extend({
+	async toResolveTruthy(received) {
+		if (!isPromise(received)) return {
+			message: () => "a promise is expected",
+			pass: false
+		};
+		const r = await received;
+		return {
+			pass: !!r,
+			message: () => `Expected promise to resolve to a truthy value, but got ${r}`
+		};
+	},
+	async toResolveFalsy(received) {
+		if (!isPromise(received)) return {
+			message: () => "a promise is expected",
+			pass: false
+		};
+		const r = await received;
+		return {
+			pass: !r,
+			message: () => `Expected promise to resolve to a falsy value, but got ${r}`
+		};
+	},
+	async toResolveNull(received) {
+		if (!isPromise(received)) return {
+			message: () => "a promise is expected",
+			pass: false
+		};
+		const r = await received;
+		return {
+			pass: r === null,
+			message: () => `Expected promise to resolve to a null value, but got ${r}`
+		};
+	},
+	async toResolveWithLength(received, length) {
+		const r = await received;
+		return {
+			pass: Array.isArray(r) && r.length === length,
+			message: () => `Expected promise to resolve with an array with length ${length}, but got ${r}`
+		};
+	},
+	async toBeRejectedNotFound(received) {
+		if (!isPromise(received)) return {
+			message: () => "a promise is expected",
+			pass: false
+		};
+		try {
+			await received;
+		} catch (err) {
+			return expectErrorReason(err, _zenstackhq_orm.ORMErrorReason.NOT_FOUND);
+		}
+		return {
+			message: () => `expected NotFoundError, got no error`,
+			pass: false
+		};
+	},
+	async toBeRejectedByPolicy(received, expectedMessages) {
+		if (!isPromise(received)) return {
+			message: () => "a promise is expected",
+			pass: false
+		};
+		try {
+			await received;
+		} catch (err) {
+			if (expectedMessages && err instanceof _zenstackhq_orm.ORMError && err.reason === _zenstackhq_orm.ORMErrorReason.REJECTED_BY_POLICY) {
+				const r = expectErrorMessages(expectedMessages, err.message || "");
+				if (r) return r;
+			}
+			return expectErrorReason(err, _zenstackhq_orm.ORMErrorReason.REJECTED_BY_POLICY);
+		}
+		return {
+			message: () => `expected PolicyError, got no error`,
+			pass: false
+		};
+	},
+	async toBeRejectedByValidation(received, expectedMessages) {
+		if (!isPromise(received)) return {
+			message: () => "a promise is expected",
+			pass: false
+		};
+		try {
+			await received;
+		} catch (err) {
+			if (expectedMessages && err instanceof _zenstackhq_orm.ORMError && err.reason === _zenstackhq_orm.ORMErrorReason.INVALID_INPUT) {
+				const r = expectErrorMessages(expectedMessages, err.message || "");
+				if (r) return r;
+			}
+			return expectErrorReason(err, _zenstackhq_orm.ORMErrorReason.INVALID_INPUT);
+		}
+		return {
+			message: () => `expected InputValidationError, got no error`,
+			pass: false
+		};
+	}
 });
+//#endregion
+exports.TEST_MYSQL_CONFIG = TEST_MYSQL_CONFIG;
+exports.TEST_MYSQL_URL = TEST_MYSQL_URL;
+exports.TEST_PG_CONFIG = TEST_PG_CONFIG;
+exports.TEST_PG_URL = TEST_PG_URL;
+exports.createPolicyTestClient = createPolicyTestClient;
+exports.createTestClient = createTestClient;
+exports.createTestProject = createTestProject;
+exports.generateTsSchema = generateTsSchema;
+exports.generateTsSchemaFromFile = generateTsSchemaFromFile;
+exports.generateTsSchemaInPlace = generateTsSchemaInPlace;
+exports.getTestDbProvider = getTestDbProvider;
+exports.loadSchema = loadSchema;
+exports.loadSchemaWithError = loadSchemaWithError;
+exports.testLogger = testLogger;
+
 //# sourceMappingURL=index.cjs.map