@zenstackhq/testtools 3.5.6 → 3.6.0

package/dist/index.js

@@ -1,613 +0,0 @@
-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 { glob } from "glob";
-import { MysqlDialect, PostgresDialect, SqliteDialect } from "kysely";
-import { createPool as createMysqlPool } from "mysql2";
-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 { match as match2 } from "ts-pattern";
-import { expect as expect2 } from "vitest";
-
-// src/project.ts
-import fs from "fs";
-import path from "path";
-import tmp from "tmp";
-function createTestProject(zmodelContent) {
-  const { name: workDir } = tmp.dirSync({
-    unsafeCleanup: true
-  });
-  fs.mkdirSync(path.join(workDir, "node_modules"));
-  const nodeModules = fs.readdirSync(path.join(__dirname, "../node_modules"));
-  for (const entry of nodeModules) {
-    if (entry.startsWith("@zenstackhq")) {
-      continue;
-    }
-    fs.symlinkSync(path.join(__dirname, "../node_modules", entry), path.join(workDir, "node_modules", entry), "dir");
-  }
-  const zenstackPackages = [
-    "language",
-    "sdk",
-    "schema",
-    "orm",
-    "cli"
-  ];
-  fs.mkdirSync(path.join(workDir, "node_modules/@zenstackhq"));
-  for (const pkg of zenstackPackages) {
-    fs.symlinkSync(path.join(__dirname, `../../${pkg}`), path.join(workDir, `node_modules/@zenstackhq/${pkg}`), "dir");
-  }
-  fs.writeFileSync(path.join(workDir, "package.json"), JSON.stringify({
-    name: "test",
-    version: "1.0.0",
-    type: "module"
-  }, null, 4));
-  fs.writeFileSync(path.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) {
-    fs.writeFileSync(path.join(workDir, "schema.zmodel"), zmodelContent);
-  }
-  return workDir;
-}
-__name(createTestProject, "createTestProject");
-
-// src/schema.ts
-import { invariant } from "@zenstackhq/common-helpers";
-import { TsSchemaGenerator } from "@zenstackhq/sdk";
-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 `
-datasource db {
-    provider = 'sqlite'
-    url = '${dbUrl ?? "file:./test.db"}'
-}
-`;
-  }).with("postgresql", () => {
-    return `
-datasource db {
-    provider = 'postgresql'
-    url = '${dbUrl ?? "postgres://postgres:postgres@localhost:5432/db"}'
-}
-`;
-  }).with("mysql", () => {
-    return `
-datasource db {
-    provider = 'mysql'
-    url = '${dbUrl ?? "mysql://root:mysql@localhost:3306/db"}'
-}
-`;
-  }).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);
-}
-__name(replacePlaceholders, "replacePlaceholders");
-async function generateTsSchema(schemaText, provider = "sqlite", dbUrl, extraSourceFiles, withLiteSchema, extraZModelFiles) {
-  const workDir = createTestProject();
-  const zmodelPath = path2.join(workDir, "schema.zmodel");
-  const noPrelude = schemaText.includes("datasource ");
-  fs2.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 = path2.join(workDir, name);
-      fs2.mkdirSync(path2.dirname(filePath), {
-        recursive: true
-      });
-      fs2.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 TsSchemaGenerator();
-  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);
-      fs2.mkdirSync(path2.dirname(filePath), {
-        recursive: true
-      });
-      fs2.writeFileSync(filePath, content);
-    }
-  }
-  return {
-    ...await compileAndLoad(workDir),
-    model: result.model
-  };
-}
-__name(generateTsSchema, "generateTsSchema");
-async function compileAndLoad(workDir) {
-  execSync("npx tsc", {
-    cwd: 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,
-    schemaLite: moduleLite?.schema
-  };
-}
-__name(compileAndLoad, "compileAndLoad");
-function generateTsSchemaFromFile(filePath) {
-  const schemaText = fs2.readFileSync(filePath, "utf8");
-  return generateTsSchema(schemaText);
-}
-__name(generateTsSchemaFromFile, "generateTsSchemaFromFile");
-async function generateTsSchemaInPlace(schemaPath) {
-  const workDir = path2.dirname(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, {
-    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",
-    "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"
-};
-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"
-};
-var 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 = match2(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 = 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);
-  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");
-    }
-    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);
-      }
-    }
-  }
-  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: 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 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 match2(provider).with("postgresql", () => new PostgresDialect({
-    pool: new Pool({
-      ...TEST_PG_CONFIG,
-      database: dbName
-    })
-  })).with("mysql", () => new MysqlDialect({
-    pool: createMysqlPool({
-      ...TEST_MYSQL_CONFIG,
-      database: dbName
-    })
-  })).with("sqlite", () => new SqliteDialect({
-    database: new SQLite(path3.join(workDir, dbName))
-  })).exhaustive();
-}
-__name(createDialect, "createDialect");
-async function prepareDatabase(provider, dbName) {
-  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();
-  } else if (provider === "mysql") {
-    invariant2(dbName, "dbName is required");
-    const mysqlPool = createMysqlPool(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 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 {
-  TEST_MYSQL_CONFIG,
-  TEST_MYSQL_URL,
-  TEST_PG_CONFIG,
-  TEST_PG_URL,
-  createPolicyTestClient,
-  createTestClient,
-  createTestProject,
-  generateTsSchema,
-  generateTsSchemaFromFile,
-  generateTsSchemaInPlace,
-  getTestDbProvider,
-  loadSchema,
-  loadSchemaWithError,
-  testLogger
-};
-//# sourceMappingURL=index.js.map