@cedarjs/testing 7.0.0-canary.3258 → 7.0.0-rc.123

package/dist/api/mockContext.d.ts

@@ -1,5 +1,5 @@
 export interface GlobalContext extends Record<string, unknown> {
 }
-export declare const context: GlobalContext;
+export declare const context: {};
 export declare const setContext: (newContext: GlobalContext) => GlobalContext;
 //# sourceMappingURL=mockContext.d.ts.map

package/dist/api/mockContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mockContext.d.ts","sourceRoot":"","sources":["../../src/api/mockContext.ts"],"names":[],"mappings":"AAiCA,MAAM,WAAW,aAAc,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAAG;AAEjE,eAAO,MAAM,OAAO,eAAc,CAAA;AAElC,eAAO,MAAM,UAAU,GAAI,YAAY,aAAa,KAAG,aAYtD,CAAA"}
+{"version":3,"file":"mockContext.d.ts","sourceRoot":"","sources":["../../src/api/mockContext.ts"],"names":[],"mappings":"AAoCA,MAAM,WAAW,aAAc,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAAG;AAEjE,eAAO,MAAM,OAAO,IAAc,CAAA;AAElC,eAAO,MAAM,UAAU,GAAI,YAAY,aAAa,KAAG,aAKtD,CAAA"}

package/dist/api/vitest/vite-plugin-cedar-vitest-api-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vite-plugin-cedar-vitest-api-config.d.ts","sourceRoot":"","sources":["../../../src/api/vitest/vite-plugin-cedar-vitest-api-config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAIlC,wBAAgB,0BAA0B,IAAI,MAAM,CAiCnD"}
+{"version":3,"file":"vite-plugin-cedar-vitest-api-config.d.ts","sourceRoot":"","sources":["../../../src/api/vitest/vite-plugin-cedar-vitest-api-config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAIlC,wBAAgB,0BAA0B,IAAI,MAAM,CA4BnD"}

package/dist/api/vitest/vite-plugin-cedar-vitest-api-config.js

@@ -7,12 +7,7 @@ function cedarVitestApiConfigPlugin() {
       return {
         define: getEnvVarDefinitions(),
         ssr: {
-          // `@cedarjs/tenancy` reads and writes the request context, which
-          // the api test setup replaces with a mock. The mock only reaches
-          // code Vite processes, so the tenancy runtime has to be bundled
-          // rather than loaded as an external dependency, or a service under
-          // test and its Prisma extension would see different contexts.
-          noExternal: ["@cedarjs/testing", "@cedarjs/tenancy"]
+          noExternal: ["@cedarjs/testing"]
         },
         resolve: {
           alias: {

package/dist/api/vitest/vitest-api.setup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vitest-api.setup.d.ts","sourceRoot":"","sources":["../../../src/api/vitest/vitest-api.setup.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AA4C1D,OAAO,CAAC,MAAM,CAAC;IAEb,IAAI,eAAe,EAAE,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,KAAK,IAAI,CAAA;CAC3E;AAUD,OAAO,CAAC,MAAM,CAAC;IAEb,IAAI,cAAc,EAAE,cAAc,CAAA;IAElC,IAAI,uBAAuB,EAAE,OAAO,CAAA;CACrC"}
+{"version":3,"file":"vitest-api.setup.d.ts","sourceRoot":"","sources":["../../../src/api/vitest/vitest-api.setup.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AA0C1D,OAAO,CAAC,MAAM,CAAC;IAEb,IAAI,eAAe,EAAE,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,KAAK,IAAI,CAAA;CAC3E;AAUD,OAAO,CAAC,MAAM,CAAC;IAEb,IAAI,cAAc,EAAE,cAAc,CAAA;IAElC,IAAI,uBAAuB,EAAE,OAAO,CAAA;CACrC"}

package/dist/api/vitest/vitest-api.setup.js

@@ -3,7 +3,6 @@ import path from "node:path";
 import { afterAll, beforeEach, it, describe, vi, beforeAll } from "vitest";
 import { getPaths, getPrismaSchemas } from "@cedarjs/project-config";
 import { defineScenario } from "@cedarjs/testing/api";
-import { emptyTablesInWorkingOrder } from "./teardown.js";
 const mockContextStore = vi.hoisted(() => /* @__PURE__ */ new Map());
 const mockContext = vi.hoisted(
   () => new Proxy(
@@ -39,6 +38,7 @@ globalThis.mockCurrentUser = (currentUser) => {
 };
 globalThis.defineScenario = defineScenario;
 const cedarPaths = getPaths();
+const HANDLED_ERRORS = [1451, 1811, 23001, 23503];
 const TEARDOWN_CACHE_PATH = path.join(
   cedarPaths.generated.base,
   "scenarioTeardown.json"
@@ -132,12 +132,23 @@ async function teardown() {
   }
   const quoteStyle2 = await getQuoteStyle();
   const projectDb = await getProjectDb();
-  teardownOrder = await emptyTablesInWorkingOrder(
-    teardownOrder,
-    (modelName) => projectDb.$executeRawUnsafe(
-      `DELETE FROM ${quoteStyle2}${modelName}${quoteStyle2}`
-    )
-  );
+  for (const modelName of teardownOrder) {
+    try {
+      const query = `DELETE FROM ${quoteStyle2}${modelName}${quoteStyle2}`;
+      await projectDb.$executeRawUnsafe(query);
+    } catch (e) {
+      console.error("teardown error\n", e);
+      const match = isErrorWithMessage(e) && e.message.match(/Code: `(\d+)`/);
+      if (match && HANDLED_ERRORS.includes(parseInt(match[1]))) {
+        const index = teardownOrder.indexOf(modelName);
+        teardownOrder[index] = null;
+        teardownOrder.push(modelName);
+      } else {
+        throw e;
+      }
+    }
+  }
+  teardownOrder = teardownOrder.filter((val) => val);
   if (!isIdenticalArray(teardownOrder, originalTeardownOrder)) {
     originalTeardownOrder = deepCopy(teardownOrder);
     fs.writeFileSync(TEARDOWN_CACHE_PATH, JSON.stringify(teardownOrder));
@@ -216,8 +227,7 @@ async function getQuoteStyle() {
 }
 async function getProjectDb() {
   const libDb = await import(`${cedarPaths.api.lib}/db`);
-  const db = libDb.db;
-  return typeof db?.$withoutTenant === "function" ? db.$withoutTenant() : db;
+  return libDb.db;
 }
 function isIdenticalArray(a, b) {
   return JSON.stringify(a) === JSON.stringify(b);
@@ -225,6 +235,9 @@ function isIdenticalArray(a, b) {
 function deepCopy(obj) {
   return JSON.parse(JSON.stringify(obj));
 }
+function isErrorWithMessage(e) {
+  return !!e && typeof e === "object" && "message" in e && typeof e.message === "string";
+}
 function isErrorWithCode(e) {
   return !!e && typeof e === "object" && "code" in e && typeof e.code === "string";
 }

package/dist/cjs/api/apiFunction.d.ts

@@ -0,0 +1,37 @@
+import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from 'aws-lambda';
+import type { SupportedVerifierTypes } from '@cedarjs/api/webhooks';
+interface BuildEventParams extends Partial<APIGatewayProxyEvent> {
+    payload?: string | null | Record<any, any>;
+    signature?: string;
+    signatureHeader?: string;
+    headers?: APIGatewayProxyEventHeaders;
+}
+/**
+ * @description Use this to mock out the http request event that is received by your function in unit tests
+ *
+ * @example Mocking sending headers
+ * mockHttpEvent({header: {'X-Custom-Header': 'bazinga'}})
+ *
+ * @example Adding a JSON payload
+ * mockHttpEvent({payload: JSON.stringify(mockedRequestBody)})
+ *
+ * @returns APIGatewayProxyEvent
+ */
+export declare const mockHttpEvent: ({ payload, signature, signatureHeader, queryStringParameters, httpMethod, headers, path, isBase64Encoded, ...others }: BuildEventParams) => APIGatewayProxyEvent;
+/**
+ * @description Use this function to mock the http event's context
+ * @see: https://docs.aws.amazon.com/lambda/latest/dg/nodejs-context.html
+ **/
+export declare const mockContext: () => Context;
+interface MockedSignedWebhookParams extends Omit<BuildEventParams, 'signature' | 'signatureHeader'> {
+    signatureType: Exclude<SupportedVerifierTypes, 'skipVerifier'>;
+    signatureHeader: string;
+    secret: string;
+}
+/**
+ * @description Use this function to mock a signed webhook
+ * @see https://cedarjs.com/docs/webhooks#webhooks
+ **/
+export declare const mockSignedWebhook: ({ payload, signatureType, signatureHeader, secret, ...others }: MockedSignedWebhookParams) => APIGatewayProxyEvent;
+export {};
+//# sourceMappingURL=apiFunction.d.ts.map

package/dist/cjs/api/apiFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiFunction.d.ts","sourceRoot":"","sources":["../../../src/api/apiFunction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,2BAA2B,EAC3B,OAAO,EACR,MAAM,YAAY,CAAA;AAEnB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAGnE,UAAU,gBAAiB,SAAQ,OAAO,CAAC,oBAAoB,CAAC;IAC9D,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;IAC1C,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,OAAO,CAAC,EAAE,2BAA2B,CAAA;CACtC;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,GAAI,uHAU3B,gBAAgB,KAAG,oBAgCrB,CAAA;AAED;;;IAGI;AACJ,eAAO,MAAM,WAAW,QAAO,OAI9B,CAAA;AAED,UAAU,yBAA0B,SAAQ,IAAI,CAC9C,gBAAgB,EAChB,WAAW,GAAG,iBAAiB,CAChC;IACC,aAAa,EAAE,OAAO,CAAC,sBAAsB,EAAE,cAAc,CAAC,CAAA;IAC9D,eAAe,EAAE,MAAM,CAAA;IACvB,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;;IAGI;AACJ,eAAO,MAAM,iBAAiB,GAAI,gEAM/B,yBAAyB,yBAe3B,CAAA"}

package/dist/cjs/api/apiFunction.js

@@ -0,0 +1,89 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var apiFunction_exports = {};
+__export(apiFunction_exports, {
+  mockContext: () => mockContext,
+  mockHttpEvent: () => mockHttpEvent,
+  mockSignedWebhook: () => mockSignedWebhook
+});
+module.exports = __toCommonJS(apiFunction_exports);
+var import_webhooks = require("@cedarjs/api/webhooks");
+const mockHttpEvent = ({
+  payload = null,
+  signature,
+  signatureHeader,
+  queryStringParameters = null,
+  httpMethod = "GET",
+  headers = {},
+  path = "",
+  isBase64Encoded = false,
+  ...others
+}) => {
+  if (signature && signatureHeader) {
+    headers[signatureHeader.toLocaleLowerCase()] = signature;
+  }
+  const payloadAsString = typeof payload === "string" ? payload : JSON.stringify(payload);
+  const body = payload === null ? null : isBase64Encoded ? Buffer.from(payloadAsString || "").toString("base64") : payloadAsString;
+  return {
+    body,
+    headers,
+    multiValueHeaders: {},
+    isBase64Encoded,
+    path,
+    pathParameters: null,
+    stageVariables: null,
+    httpMethod,
+    queryStringParameters,
+    // @ts-expect-error not required for mocks
+    requestContext: null,
+    // @ts-expect-error not required for mocks
+    resource: null,
+    multiValueQueryStringParameters: null,
+    ...others
+  };
+};
+const mockContext = () => {
+  const context = {};
+  return context;
+};
+const mockSignedWebhook = ({
+  payload = null,
+  signatureType,
+  signatureHeader,
+  secret,
+  ...others
+}) => {
+  const payloadAsString = typeof payload === "string" ? payload : JSON.stringify(payload);
+  const signature = (0, import_webhooks.signPayload)(signatureType, {
+    payload: payloadAsString,
+    secret
+  });
+  return mockHttpEvent({
+    payload,
+    signature,
+    signatureHeader,
+    ...others
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mockContext,
+  mockHttpEvent,
+  mockSignedWebhook
+});

package/dist/cjs/api/checkTestDatabase.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Redacts credentials from a database connection string so it's safe to
+ * print. Handles both URI-style authority credentials, e.g.
+ * `postgres://user:pass@host/db` -> `postgres://user:***@host/db`, and
+ * semicolon-delimited key/value credentials used by SQL Server connection
+ * strings, e.g. `Server=host;Password=secret;` -> `Server=host;Password=***;`.
+ */
+export declare function redactDatabaseUrl(url: string): string;
+/**
+ * Checks that the `DATABASE_URL` about to be used for tests matches the
+ * datasource provider configured in `schema.prisma`, and throws an
+ * actionable error if they don't match.
+ *
+ * Without this check, running `prisma db push`/`migrate reset` against a
+ * mismatched provider/URL combination (e.g. a leftover sqlite fallback URL
+ * with a `postgresql` schema) can hang indefinitely with no output, instead
+ * of failing fast. See https://github.com/cedarjs/cedar/issues/2284.
+ *
+ * If the provider can't be determined (e.g. `schema.prisma` doesn't exist
+ * yet), this is a no-op — Prisma itself will surface the problem.
+ */
+export declare function checkTestDatabaseUrlMatchesProvider(databaseUrl: string, usedFallback: boolean): Promise<void>;
+/**
+ * Guards `cedar test api`'s destructive database reset by *identity*, not
+ * just provider: refuses to run when the resolved test database is the same
+ * database as `DATABASE_URL` — same host, port, and database name, or the
+ * same sqlite file.
+ *
+ * This is deliberately the only check, rather than also requiring the
+ * database's *name* to look test-like (e.g. containing "test" or "e2e"). A
+ * naming convention doesn't hold for managed Postgres providers with a
+ * fixed default database name shared by every project — every Supabase
+ * project's database is named `postgres`, for instance — so it can't tell a
+ * real project's database apart from a dedicated test one by name alone.
+ * Whether the two connection strings resolve to the same database is the
+ * one fact that holds across every provider.
+ *
+ * When there's no `DATABASE_URL` at all to compare against, this fails
+ * closed rather than skipping the check: an explicit `TEST_DATABASE_URL`
+ * with nothing to confirm it's not the app's real database is refused,
+ * since there'd be no way to tell it apart from one that is. Cedar's own
+ * generated sqlite fallback (`usedFallback`) is exempt from that fail-closed
+ * refusal — it's a path only Cedar controls, so there's no need to force a
+ * `DATABASE_URL` to exist just to permit it — but it still runs through the
+ * same-database comparison below whenever a `DATABASE_URL` is present, so a
+ * project whose real database happens to live at that same generated path
+ * is still caught.
+ */
+export declare function checkTestDatabaseIdentity(testDatabaseUrl: string, mainDatabaseUrl: string | undefined, usedFallback: boolean): void;
+//# sourceMappingURL=checkTestDatabase.d.ts.map

package/dist/cjs/api/checkTestDatabase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkTestDatabase.d.ts","sourceRoot":"","sources":["../../../src/api/checkTestDatabase.ts"],"names":[],"mappings":"AAoBA;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAIrD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,mCAAmC,CACvD,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,OAAO,iBAmCtB;AAuHD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,yBAAyB,CACvC,eAAe,EAAE,MAAM,EACvB,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,YAAY,EAAE,OAAO,QAkCtB"}

package/dist/cjs/api/checkTestDatabase.js

@@ -0,0 +1,182 @@
+"use strict";
+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 __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;
+};
+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);
+var checkTestDatabase_exports = {};
+__export(checkTestDatabase_exports, {
+  checkTestDatabaseIdentity: () => checkTestDatabaseIdentity,
+  checkTestDatabaseUrlMatchesProvider: () => checkTestDatabaseUrlMatchesProvider,
+  redactDatabaseUrl: () => redactDatabaseUrl
+});
+module.exports = __toCommonJS(checkTestDatabase_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_project_config = require("@cedarjs/project-config");
+const PROVIDER_URL_SCHEMES = {
+  sqlite: ["file:"],
+  postgresql: ["postgres:", "postgresql:"],
+  postgres: ["postgres:", "postgresql:"],
+  cockroachdb: ["postgres:", "postgresql:"],
+  mysql: ["mysql:"],
+  sqlserver: ["sqlserver:"],
+  mongodb: ["mongodb:", "mongodb+srv:"]
+};
+function getUrlScheme(url) {
+  const match = url.match(/^([a-z][a-z0-9+.-]*:)/i);
+  return match?.[1]?.toLowerCase();
+}
+function redactDatabaseUrl(url) {
+  return url.replace(/:\/\/([^:/?#]+):([^@/?#]+)@/, "://$1:***@").replace(/((?:^|;)\s*password\s*=)[^;]*/gi, "$1***");
+}
+async function checkTestDatabaseUrlMatchesProvider(databaseUrl, usedFallback) {
+  let provider;
+  try {
+    provider = await (0, import_project_config.getPrismaDatasourceProvider)();
+  } catch {
+    return;
+  }
+  const expectedSchemes = PROVIDER_URL_SCHEMES[provider];
+  if (!expectedSchemes) {
+    return;
+  }
+  const actualScheme = getUrlScheme(databaseUrl);
+  if (actualScheme && expectedSchemes.includes(actualScheme)) {
+    return;
+  }
+  const redactedUrl = redactDatabaseUrl(databaseUrl);
+  const reason = usedFallback ? `TEST_DATABASE_URL is not set, so the default sqlite test database was used (${redactedUrl}), but your schema.prisma is configured for "${provider}". Set TEST_DATABASE_URL to a "${provider}" connection string to run tests.` : `TEST_DATABASE_URL (${redactedUrl}) does not match the "${provider}" provider configured in schema.prisma. Update TEST_DATABASE_URL to a "${provider}" connection string.`;
+  throw new Error(
+    `Test database URL does not match your Prisma schema's provider.
+
+${reason}`
+  );
+}
+const DEFAULT_PORTS = {
+  "postgresql:": "5432",
+  "mysql:": "3306",
+  "sqlserver:": "1433",
+  "mongodb:": "27017"
+};
+function normalizeScheme(scheme) {
+  return scheme === "postgres:" ? "postgresql:" : scheme;
+}
+function normalizeHost(host) {
+  return host.toLowerCase().replace(/\.$/, "");
+}
+function parseSqlServerIdentity(url) {
+  const [authority, ...params] = url.split(";");
+  const match = authority.match(
+    /^([a-z][a-z0-9+.-]*:)\/\/([^:/?#]+)(?::(\d+))?/i
+  );
+  if (!match) {
+    return void 0;
+  }
+  const [, scheme, host, port] = match;
+  const databaseParam = params.find(
+    (param) => /^\s*(?:database|initial\s+catalog)\s*=/i.test(param)
+  );
+  const database = databaseParam?.slice(databaseParam.indexOf("=") + 1).trim();
+  return {
+    scheme: scheme.toLowerCase(),
+    host: normalizeHost(host),
+    port,
+    database
+  };
+}
+function parseUriIdentity(url) {
+  try {
+    const parsed = new URL(url);
+    const database = decodeURIComponent(parsed.pathname.replace(/^\//, "")).split("/")[0] || void 0;
+    return {
+      scheme: parsed.protocol.toLowerCase(),
+      host: parsed.hostname ? normalizeHost(parsed.hostname) : void 0,
+      port: parsed.port || void 0,
+      database
+    };
+  } catch {
+    return void 0;
+  }
+}
+function parseDatabaseIdentity(url) {
+  const scheme = getUrlScheme(url);
+  if (!scheme) {
+    return void 0;
+  }
+  if (scheme === "file:") {
+    return { scheme, database: import_node_path.default.resolve(url.slice("file:".length)) };
+  }
+  if (scheme === "sqlserver:") {
+    return parseSqlServerIdentity(url);
+  }
+  return parseUriIdentity(url);
+}
+function identitiesMatch(a, b) {
+  const schemeA = normalizeScheme(a.scheme);
+  const schemeB = normalizeScheme(b.scheme);
+  if (schemeA !== schemeB) {
+    return false;
+  }
+  if (schemeA === "file:") {
+    return !!a.database && a.database === b.database;
+  }
+  if (!a.database || !b.database || a.database !== b.database) {
+    return false;
+  }
+  const portA = a.port || DEFAULT_PORTS[schemeA] || "";
+  const portB = b.port || DEFAULT_PORTS[schemeA] || "";
+  return (a.host ?? "") === (b.host ?? "") && portA === portB;
+}
+function checkTestDatabaseIdentity(testDatabaseUrl, mainDatabaseUrl, usedFallback) {
+  if (!mainDatabaseUrl) {
+    if (usedFallback) {
+      return;
+    }
+    const redactedTestUrl = redactDatabaseUrl(testDatabaseUrl);
+    throw new Error(
+      `TEST_DATABASE_URL (${redactedTestUrl}) is set, but there's no DATABASE_URL to confirm it isn't the same database your app actually uses. Refusing to run a destructive reset without that confirmation.
+
+Set DATABASE_URL (even to a placeholder) so Cedar can verify TEST_DATABASE_URL points somewhere different.`
+    );
+  }
+  const sameRawUrl = mainDatabaseUrl === testDatabaseUrl;
+  const testIdentity = parseDatabaseIdentity(testDatabaseUrl);
+  const mainIdentity = parseDatabaseIdentity(mainDatabaseUrl);
+  const sameParsedIdentity = !!testIdentity && !!mainIdentity && identitiesMatch(testIdentity, mainIdentity);
+  if (sameRawUrl || sameParsedIdentity) {
+    const redactedTestUrl = redactDatabaseUrl(testDatabaseUrl);
+    throw new Error(
+      `TEST_DATABASE_URL (${redactedTestUrl}) points at the same database as DATABASE_URL. Refusing to run a destructive reset against your app's main database.
+
+Set TEST_DATABASE_URL to a dedicated test database.`
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkTestDatabaseIdentity,
+  checkTestDatabaseUrlMatchesProvider,
+  redactDatabaseUrl
+});

package/dist/cjs/api/directive.d.ts

@@ -0,0 +1,51 @@
+import type { A } from 'ts-toolbelt';
+import type { DirectiveParams, ValidatorDirective, TransformerDirective } from '@cedarjs/graphql-server';
+export { getDirectiveName } from '@cedarjs/graphql-server';
+interface DirectiveMocker {
+    (directive: ValidatorDirective, executionMock: A.Compute<Omit<Partial<DirectiveParams>, 'resolvedValue'>>): any;
+}
+type TransformerMock = A.Compute<Omit<Partial<DirectiveParams>, 'resolvedValue'>> & {
+    mockedResolvedValue: any;
+};
+interface DirectiveMocker {
+    (directive: TransformerDirective, executionMock: TransformerMock): any;
+}
+/**
+ * @description
+ *
+ * Used for writing both synchronous and asynchronous directive tests e.g.
+ *
+ * - Transformer directives can be passed mockedResolvedValue
+ * - Validator directives should check for errors thrown in certain situations
+ * - Can provide args, directiveArgs and context to mock directive execution
+ *
+ * @example
+ *
+ * Synchronous transformer directive:
+ *
+ * ```ts
+ * const mockExecution = mockRedwoodDirective(myTransformer, {
+ *   context: currentUser,
+ *   mockedResolvedValue: 'Original Value',
+ * })
+ *
+ * expect(mockExecution).not.toThrow()
+ * expect(mockExecution()).toEqual('Transformed Value')
+ * ```ts
+ *
+ * @example
+ *
+ * Asynchronous transformer directive:
+ *
+ * ```ts
+ * const mockExecution = mockRedwoodDirective(myTransformer, {
+ *   context: currentUser,
+ *   mockedResolvedValue: 'Original Value',
+ * })
+ *
+ * await expect(mockExecution).resolves.not.toThrow()
+ * await expect(mockExecution()).resolves.toEqual('Transformed Value')
+ * ```
+ */
+export declare const mockRedwoodDirective: DirectiveMocker;
+//# sourceMappingURL=directive.d.ts.map

package/dist/cjs/api/directive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directive.d.ts","sourceRoot":"","sources":["../../../src/api/directive.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,aAAa,CAAA;AAGpC,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,yBAAyB,CAAA;AAGhC,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAG1D,UAAU,eAAe;IACvB,CACE,SAAS,EAAE,kBAAkB,EAC7B,aAAa,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE,eAAe,CAAC,CAAC,GACxE,GAAG,CAAA;CACP;AAED,KAAK,eAAe,GAAG,CAAC,CAAC,OAAO,CAC9B,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE,eAAe,CAAC,CAChD,GAAG;IACF,mBAAmB,EAAE,GAAG,CAAA;CACzB,CAAA;AAGD,UAAU,eAAe;IACvB,CAAC,SAAS,EAAE,oBAAoB,EAAE,aAAa,EAAE,eAAe,GAAG,GAAG,CAAA;CACvE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,oBAAoB,EAAE,eAmDlC,CAAA"}

package/dist/cjs/api/directive.js

@@ -0,0 +1,77 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var directive_exports = {};
+__export(directive_exports, {
+  getDirectiveName: () => import_graphql_server2.getDirectiveName,
+  mockRedwoodDirective: () => mockRedwoodDirective
+});
+module.exports = __toCommonJS(directive_exports);
+var import_context = require("@cedarjs/context");
+var import_graphql_server = require("@cedarjs/graphql-server");
+var import_graphql_server2 = require("@cedarjs/graphql-server");
+const mockRedwoodDirective = (directive, executionMock) => {
+  const { directiveArgs, context, ...others } = executionMock;
+  if (directive.onResolvedValue.constructor.name === "AsyncFunction") {
+    return async () => {
+      if (context !== void 0) {
+        (0, import_context.setContext)(context);
+      }
+      if (directive.type === import_graphql_server.DirectiveType.TRANSFORMER) {
+        const { mockedResolvedValue } = others;
+        return directive.onResolvedValue({
+          resolvedValue: mockedResolvedValue,
+          directiveArgs: directiveArgs ?? {},
+          context: import_context.context,
+          ...others
+        });
+      } else {
+        await directive.onResolvedValue({
+          directiveArgs: directiveArgs ?? {},
+          context: import_context.context,
+          ...others
+        });
+      }
+    };
+  }
+  return () => {
+    if (context !== void 0) {
+      (0, import_context.setContext)(context);
+    }
+    if (directive.type === import_graphql_server.DirectiveType.TRANSFORMER) {
+      const { mockedResolvedValue } = others;
+      return directive.onResolvedValue({
+        resolvedValue: mockedResolvedValue,
+        directiveArgs: directiveArgs ?? {},
+        context: import_context.context,
+        ...others
+      });
+    } else {
+      directive.onResolvedValue({
+        directiveArgs: directiveArgs ?? {},
+        context: import_context.context,
+        ...others
+      });
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDirectiveName,
+  mockRedwoodDirective
+});

package/dist/cjs/api/index.d.ts

@@ -0,0 +1,4 @@
+export * from './apiFunction.js';
+export * from './scenario.js';
+export * from './directive.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,eAAe,CAAA;AAC7B,cAAc,gBAAgB,CAAA"}

package/dist/cjs/api/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var api_exports = {};
+module.exports = __toCommonJS(api_exports);
+__reExport(api_exports, require("./apiFunction.js"), module.exports);
+__reExport(api_exports, require("./scenario.js"), module.exports);
+__reExport(api_exports, require("./directive.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./apiFunction.js"),
+  ...require("./scenario.js"),
+  ...require("./directive.js")
+});

package/dist/cjs/api/mockContext.d.ts

@@ -0,0 +1,5 @@
+export interface GlobalContext extends Record<string, unknown> {
+}
+export declare const context: {};
+export declare const setContext: (newContext: GlobalContext) => GlobalContext;
+//# sourceMappingURL=mockContext.d.ts.map

package/dist/cjs/api/mockContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockContext.d.ts","sourceRoot":"","sources":["../../../src/api/mockContext.ts"],"names":[],"mappings":"AAoCA,MAAM,WAAW,aAAc,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAAG;AAEjE,eAAO,MAAM,OAAO,IAAc,CAAA;AAElC,eAAO,MAAM,UAAU,GAAI,YAAY,aAAa,KAAG,aAKtD,CAAA"}