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

package/config/jest/api/RedwoodApiJestEnv.d.ts

@@ -0,0 +1,11 @@
+import type { EnvironmentContext, JestEnvironmentConfig } from '@jest/environment';
+import { TestEnvironment } from 'jest-environment-node';
+declare class RedwoodApiJestEnvironment extends TestEnvironment {
+    private testPath;
+    constructor(config: JestEnvironmentConfig, context: EnvironmentContext);
+    setup(): Promise<void>;
+    teardown(): Promise<void>;
+    getVmContext(): import("vm").Context | null;
+}
+export default RedwoodApiJestEnvironment;
+//# sourceMappingURL=RedwoodApiJestEnv.d.ts.map

package/config/jest/api/RedwoodApiJestEnv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedwoodApiJestEnv.d.ts","sourceRoot":"","sources":["../../../../../src/config/jest/api/RedwoodApiJestEnv.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,qBAAqB,EACtB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAEvD,cAAM,yBAA0B,SAAQ,eAAe;IACrD,OAAO,CAAC,QAAQ,CAAQ;gBAEZ,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,kBAAkB;IAKhE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAMtB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAI/B,YAAY;CAUb;AAED,eAAe,yBAAyB,CAAA"}

package/config/jest/api/RedwoodApiJestEnv.js

@@ -0,0 +1,48 @@
+"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 RedwoodApiJestEnv_exports = {};
+__export(RedwoodApiJestEnv_exports, {
+  default: () => RedwoodApiJestEnv_default
+});
+module.exports = __toCommonJS(RedwoodApiJestEnv_exports);
+var import_jest_environment_node = require("jest-environment-node");
+class RedwoodApiJestEnvironment extends import_jest_environment_node.TestEnvironment {
+  testPath;
+  constructor(config, context) {
+    super(config, context);
+    this.testPath = context.testPath;
+  }
+  async setup() {
+    await super.setup();
+    this.global.testPath = this.testPath;
+  }
+  async teardown() {
+    await super.teardown();
+  }
+  getVmContext() {
+    return super.getVmContext();
+  }
+  // async handleTestEvent(event, state) {
+  //   if (event.name === 'test_start') {
+  //     // Link to event docs:
+  //     // https://github.com/facebook/jest/blob/master/packages/jest-types/src/Circus.ts
+  //   }
+  // }
+}
+var RedwoodApiJestEnv_default = RedwoodApiJestEnvironment;

package/config/jest/api/apiBabelConfig.d.ts

@@ -0,0 +1,5 @@
+import { getApiSideDefaultBabelConfig } from '@cedarjs/babel-config';
+type ConfigType = Omit<ReturnType<typeof getApiSideDefaultBabelConfig>, 'babelrc'>;
+declare const config: ConfigType;
+export default config;
+//# sourceMappingURL=apiBabelConfig.d.ts.map

package/config/jest/api/apiBabelConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiBabelConfig.d.ts","sourceRoot":"","sources":["../../../../../src/config/jest/api/apiBabelConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,4BAA4B,EAG7B,MAAM,uBAAuB,CAAA;AAO9B,KAAK,UAAU,GAAG,IAAI,CACpB,UAAU,CAAC,OAAO,4BAA4B,CAAC,EAC/C,SAAS,CACV,CAAA;AAED,QAAA,MAAM,MAAM,EAAE,UAMb,CAAA;AAED,eAAe,MAAM,CAAA"}

package/config/jest/api/apiBabelConfig.js

@@ -0,0 +1,34 @@
+"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 apiBabelConfig_exports = {};
+__export(apiBabelConfig_exports, {
+  default: () => apiBabelConfig_default
+});
+module.exports = __toCommonJS(apiBabelConfig_exports);
+var import_babel_config = require("@cedarjs/babel-config");
+const { babelrc: _b, ...defaultBabelConfig } = (0, import_babel_config.getApiSideDefaultBabelConfig)();
+const config = {
+  ...defaultBabelConfig,
+  plugins: (0, import_babel_config.getApiSideBabelPlugins)(),
+  presets: (0, import_babel_config.getApiSideBabelPresets)({
+    presetEnv: true
+    // jest needs code transpiled
+  })
+};
+var apiBabelConfig_default = config;

package/config/jest/api/globalSetup.d.ts

@@ -0,0 +1,3 @@
+import 'dotenv-defaults/config';
+export default function (): Promise<void>;
+//# sourceMappingURL=globalSetup.d.ts.map

package/config/jest/api/globalSetup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalSetup.d.ts","sourceRoot":"","sources":["../../../../../src/config/jest/api/globalSetup.ts"],"names":[],"mappings":"AAEA,OAAO,wBAAwB,CAAA;AAW/B,0CAqCC"}

package/config/jest/api/globalSetup.js

@@ -0,0 +1,63 @@
+"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 globalSetup_exports = {};
+__export(globalSetup_exports, {
+  default: () => globalSetup_default
+});
+module.exports = __toCommonJS(globalSetup_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_config = require("dotenv-defaults/config");
+var import_execa = __toESM(require("execa"), 1);
+var import_project_config = require("@cedarjs/project-config");
+var import_packageManager = require("@cedarjs/project-config/packageManager");
+var import_checkTestDatabase = require("@cedarjs/testing/dist/cjs/api/checkTestDatabase.js");
+async function globalSetup_default() {
+  if (process.env.SKIP_DB_PUSH === "1") {
+    return;
+  }
+  const cedarPaths = (0, import_project_config.getPaths)();
+  const defaultDb = `file:${import_node_path.default.join(cedarPaths.generated.base, "test.db")}`;
+  const usedFallback = !process.env.TEST_DATABASE_URL;
+  process.env.DATABASE_URL = process.env.TEST_DATABASE_URL || defaultDb;
+  await (0, import_checkTestDatabase.checkTestDatabaseUrlMatchesProvider)(
+    process.env.DATABASE_URL,
+    usedFallback
+  );
+  console.log(
+    `Setting up test database: ${(0, import_checkTestDatabase.redactDatabaseUrl)(process.env.DATABASE_URL)}`
+  );
+  const command = process.env.TEST_DATABASE_STRATEGY === "reset" ? ["prisma", "migrate", "reset", "--force"] : ["prisma", "db", "push", "--force-reset", "--accept-data-loss"];
+  const pm = (0, import_packageManager.getPackageManager)();
+  const pmExec = pm === "pnpm" ? pm : "npx";
+  import_execa.default.sync(pmExec, ["cedar", ...command], {
+    cwd: cedarPaths.api.base,
+    stdio: "inherit",
+    env: process.env
+  });
+}

package/config/jest/api/index.d.ts

@@ -0,0 +1,3 @@
+import * as jestPreset from './jest-preset.js';
+export = jestPreset;
+//# sourceMappingURL=index.d.ts.map

package/config/jest/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/config/jest/api/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAA;AAK9C,SAAS,UAAU,CAAA"}

package/config/jest/api/index.js

@@ -0,0 +1,25 @@
+"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 __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 jestPreset = __toESM(require("./jest-preset.js"), 1);
+module.exports = jestPreset;

package/config/jest/api/jest-preset.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from 'jest';
+declare const config: Config;
+export default config;
+//# sourceMappingURL=jest-preset.d.ts.map

package/config/jest/api/jest-preset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest-preset.d.ts","sourceRoot":"","sources":["../../../../../src/config/jest/api/jest-preset.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAkClC,QAAA,MAAM,MAAM,EAAE,MA0Fb,CAAA;AAED,eAAe,MAAM,CAAA"}

package/config/jest/api/jest-preset.js

@@ -0,0 +1,140 @@
+"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 jest_preset_exports = {};
+__export(jest_preset_exports, {
+  default: () => jest_preset_default
+});
+module.exports = __toCommonJS(jest_preset_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_babel_config = require("@cedarjs/babel-config");
+var import_project_config = require("@cedarjs/project-config");
+const rwjsPaths = (0, import_project_config.getPaths)();
+const { babelrc } = (0, import_babel_config.getApiSideDefaultBabelConfig)();
+function resolveSubpath(specifier) {
+  try {
+    return require.resolve(specifier, {
+      paths: [rwjsPaths.api.base, rwjsPaths.base]
+    });
+  } catch {
+    return void 0;
+  }
+}
+const testingApiPath = resolveSubpath("@cedarjs/testing/api");
+const config = {
+  // To make sure other config option which depends on rootDir use
+  // correct path, for example, coverageDirectory
+  rootDir: rwjsPaths.base,
+  roots: [import_node_path.default.join(rwjsPaths.api.src)],
+  runner: import_node_path.default.join(__dirname, "../jest-serial-runner.js"),
+  testEnvironment: import_node_path.default.join(__dirname, "./RedwoodApiJestEnv.js"),
+  globals: {
+    __CEDARJS__TEST_IMPORTS: {
+      apiSrcPath: rwjsPaths.api.src,
+      tearDownCachePath: import_node_path.default.join(
+        rwjsPaths.generated.base,
+        "scenarioTeardown.json"
+      )
+    }
+  },
+  sandboxInjectedGlobals: ["__CEDARJS__TEST_IMPORTS"],
+  displayName: {
+    color: "redBright",
+    name: "api"
+  },
+  collectCoverageFrom: [
+    "**/*.{js,jsx,ts,tsx,mts,cts}",
+    "!**/node_modules/**",
+    "!**/dist/**"
+  ],
+  coverageDirectory: import_node_path.default.join(rwjsPaths.base, "coverage"),
+  watchPlugins: [
+    "jest-watch-typeahead/filename",
+    "jest-watch-typeahead/testname"
+  ],
+  // This runs once before all tests
+  globalSetup: import_node_path.default.join(__dirname, "./globalSetup.js"),
+  // Note this setup runs for each test file!
+  setupFilesAfterEnv: [import_node_path.default.join(__dirname, "./jest.setup.js")],
+  moduleNameMapper: {
+    "^api/(.*)$": import_node_path.default.join(rwjsPaths.base, "api/$1"),
+    "^src/(.*)$": import_node_path.default.join(rwjsPaths.api.src, "$1"),
+    // @NOTE: Import @cedarjs/testing in api tests, and it automatically remaps to the api side only
+    // This is to prevent web stuff leaking into api, and vice versa
+    ...testingApiPath ? { "^@cedarjs/testing$": testingApiPath } : {},
+    // Support for importing files with extensions (like you'd do in ESM projects)
+    "^(\\.{1,2}/.*)\\.js$": "$1"
+  },
+  transform: {
+    // `@cedarjs/context`, `@cedarjs/api`, `@cedarjs/graphql-server`, and
+    // `@cedarjs/storage` are ESM-only. Two things pull them in at the top
+    // level of a generated project's api-side test run: @cedarjs/testing's
+    // own api entry point (which virtually every test imports, for
+    // scenario/mock helpers — pulls in `@cedarjs/context` and
+    // `@cedarjs/graphql-server` via `directive.ts`, and
+    // `@cedarjs/api/webhooks` via `apiFunction.ts`), and the *user's own*
+    // generated code — the `cedar setup uploads` template imports
+    // `@cedarjs/storage`. Jest's CJS runtime can't parse the real ESM these
+    // now emit, so they need the same babel-jest carve-out the web preset
+    // already uses for ESM-only node_modules packages (see jest-preset.ts
+    // on the web side for the fuller explanation of why this is
+    // necessary).
+    "[/\\\\]node_modules[/\\\\]@cedarjs[/\\\\](context|api|graphql-server|storage)[/\\\\].+\\.js$": [
+      "babel-jest",
+      {
+        babelrc: false,
+        configFile: false,
+        presets: [
+          [require.resolve("@babel/preset-env"), { targets: { node: "20" } }]
+        ]
+      }
+    ],
+    "\\.[cm]?[jt]sx?$": [
+      "babel-jest",
+      // When jest runs tests in parallel, it serializes the config before passing down options to babel
+      // that's why these must be serializable. So ideally, we should just pass reference to a
+      // configFile or "extends" a config. But we need a few other option only at root level, so we'll pass
+      //  here and remove those keys inside "extend"ed config.
+      {
+        babelrc,
+        // babelrc can not reside inside "extend"ed config, that's why we have it here
+        configFile: import_node_path.default.resolve(__dirname, "./apiBabelConfig.js")
+      }
+    ]
+  },
+  // Jest runs api tests as CommonJS, so the ESM-only packages it reaches have
+  // to be transformed. `picoquery` is one: `@cedarjs/api/runtime` imports it,
+  // and `@cedarjs/graphql-server` pulls that module in, so any test that
+  // imports the GraphQL server (directive tests do, through
+  // `@cedarjs/testing/api`) loads it.
+  transformIgnorePatterns: [
+    "[/\\\\]node_modules[/\\\\](?!@cedarjs[/\\\\]context[/\\\\])(?!@cedarjs[/\\\\]api[/\\\\])(?!@cedarjs[/\\\\]graphql-server[/\\\\])(?!@cedarjs[/\\\\]storage[/\\\\])(?!picoquery[/\\\\])"
+  ],
+  testPathIgnorePatterns: [".scenarios.[jt]s$"]
+};
+var jest_preset_default = config;

package/config/jest/api/jest.setup.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=jest.setup.d.ts.map

package/config/jest/api/jest.setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest.setup.d.ts","sourceRoot":"","sources":["../../../../../src/config/jest/api/jest.setup.ts"],"names":[],"mappings":""}

package/config/jest/api/jest.setup.js

@@ -0,0 +1,267 @@
+"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 __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 import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_scenario = require("@cedarjs/testing/dist/cjs/api/scenario.js");
+const { apiSrcPath, tearDownCachePath } = global.__CEDARJS__TEST_IMPORTS;
+global.defineScenario = import_scenario.defineScenario;
+const mockContextStore = /* @__PURE__ */ new Map();
+const mockContext = new Proxy(
+  {},
+  {
+    get: (_target, prop) => {
+      if (prop === "toJSON") {
+        return () => mockContextStore.get("context");
+      }
+      return mockContextStore.get("context")[prop];
+    },
+    set: (_target, prop, value) => {
+      const ctx = mockContextStore.get("context");
+      ctx[prop] = value;
+      return true;
+    }
+  }
+);
+global.mockCurrentUser = (currentUser) => {
+  mockContextStore.set("context", { currentUser });
+};
+const HANDLED_ERRORS = [1451, 1811, 23001, 23503];
+const TEARDOWN_CACHE_PATH = tearDownCachePath;
+const DEFAULT_SCENARIO = "standard";
+let teardownOrder = [];
+let originalTeardownOrder = [];
+const deepCopy = (obj) => {
+  return JSON.parse(JSON.stringify(obj));
+};
+const isIdenticalArray = (a, b) => {
+  return JSON.stringify(a) === JSON.stringify(b);
+};
+const configureTeardown = async () => {
+  const { getDMMF } = require("@prisma/internals");
+  const { getPrismaSchemas } = require("@cedarjs/project-config");
+  const { schemas } = await getPrismaSchemas();
+  const schema = await getDMMF({ datamodel: schemas });
+  const schemaModels = schema.datamodel.models.map(
+    (m) => m.dbName || m.name
+  );
+  if (import_node_fs.default.existsSync(TEARDOWN_CACHE_PATH)) {
+    teardownOrder = JSON.parse(import_node_fs.default.readFileSync(TEARDOWN_CACHE_PATH).toString());
+  }
+  if (teardownOrder.length !== schemaModels.length) {
+    teardownOrder = schemaModels;
+  }
+  originalTeardownOrder = deepCopy(teardownOrder);
+};
+let quoteStyle;
+const getQuoteStyle = async () => {
+  const { getConfig: getPrismaConfig } = require("@prisma/internals");
+  const { getPrismaSchemas } = require("@cedarjs/project-config");
+  const result = await getPrismaSchemas();
+  if (!quoteStyle) {
+    const config = await getPrismaConfig({ datamodel: result.schemas });
+    switch (config.datasources?.[0]?.provider) {
+      case "mysql":
+        quoteStyle = "`";
+        break;
+      default:
+        quoteStyle = '"';
+    }
+  }
+  return quoteStyle;
+};
+const getProjectDb = async () => {
+  const { db } = require(`${apiSrcPath}/lib/db`);
+  return db;
+};
+function buildScenario(itFunc, testPath) {
+  const scenarioFunc = (...args) => {
+    let scenarioName, testName, testFunc;
+    if (args.length === 3) {
+      ;
+      [scenarioName, testName, testFunc] = args;
+    } else if (args.length === 2) {
+      scenarioName = DEFAULT_SCENARIO;
+      [testName, testFunc] = args;
+    } else {
+      throw new Error("scenario() requires 2 or 3 arguments");
+    }
+    return itFunc(testName, async () => {
+      const { scenario } = await loadScenarios(testPath, scenarioName);
+      const scenarioData = await seedScenario(scenario);
+      try {
+        const result = await testFunc(scenarioData);
+        return result;
+      } finally {
+        if (wasDbUsed()) {
+          await teardown();
+        }
+      }
+    });
+  };
+  return Object.assign(scenarioFunc, { only: scenarioFunc });
+}
+function buildDescribeScenario(describeFunc, testPath) {
+  const describeScenarioFunc = (...args) => {
+    let scenarioName, describeBlockName, describeBlock;
+    if (args.length === 3) {
+      ;
+      [scenarioName, describeBlockName, describeBlock] = args;
+    } else if (args.length === 2) {
+      scenarioName = DEFAULT_SCENARIO;
+      [describeBlockName, describeBlock] = args;
+    } else {
+      throw new Error("describeScenario() requires 2 or 3 arguments");
+    }
+    return describeFunc(describeBlockName, () => {
+      let scenarioData;
+      beforeAll(async () => {
+        const { scenario } = await loadScenarios(testPath, scenarioName);
+        scenarioData = await seedScenario(scenario);
+      });
+      afterAll(async () => {
+        if (wasDbUsed()) {
+          await teardown();
+        }
+      });
+      const getScenario = () => scenarioData;
+      describeBlock(getScenario);
+    });
+  };
+  return Object.assign(describeScenarioFunc, { only: describeScenarioFunc });
+}
+const teardown = async () => {
+  const quoteStyle2 = await getQuoteStyle();
+  for (let i = 0; i < teardownOrder.length; i++) {
+    const modelName = teardownOrder[i];
+    if (!modelName) {
+      continue;
+    }
+    try {
+      const db = await getProjectDb();
+      await db.$executeRawUnsafe(
+        `DELETE FROM ${quoteStyle2}${modelName}${quoteStyle2}`
+      );
+    } catch (e) {
+      const message = isErrorWithMessage(e) ? e.message : "";
+      const match = message.match(/Code: `(\d+)`/);
+      if (match && HANDLED_ERRORS.includes(parseInt(match[1]))) {
+        teardownOrder.splice(i, 1);
+        teardownOrder.push(modelName);
+        i--;
+      } else {
+        throw e;
+      }
+    }
+  }
+  if (!isIdenticalArray(teardownOrder, originalTeardownOrder)) {
+    originalTeardownOrder = deepCopy(teardownOrder);
+    import_node_fs.default.writeFileSync(TEARDOWN_CACHE_PATH, JSON.stringify(teardownOrder));
+  }
+};
+const seedScenario = async (scenario) => {
+  if (scenario) {
+    const scenarios = {};
+    const db = await getProjectDb();
+    for (const [model, namedFixtures] of Object.entries(scenario)) {
+      scenarios[model] = {};
+      for (const [name, createArgs] of Object.entries(namedFixtures)) {
+        if (typeof createArgs === "function") {
+          scenarios[model][name] = await db[model].create(createArgs(scenarios));
+        } else {
+          scenarios[model][name] = await db[model].create(createArgs);
+        }
+      }
+    }
+    return scenarios;
+  } else {
+    return {};
+  }
+};
+global.scenario = buildScenario(global.it, global.testPath);
+global.describeScenario = buildDescribeScenario(
+  global.describe,
+  global.testPath
+);
+const wasDbUsed = () => {
+  try {
+    const libDbPath = require.resolve(`${apiSrcPath}/lib/db`);
+    return Object.keys(require.cache).some((module2) => {
+      return module2 === libDbPath;
+    });
+  } catch {
+    return false;
+  }
+};
+jest.mock("@cedarjs/context", () => {
+  return {
+    context: mockContext,
+    setContext: (newContext) => {
+      mockContextStore.set("context", newContext);
+    }
+  };
+});
+beforeEach(() => {
+  mockContextStore.set("context", {});
+});
+beforeAll(async () => {
+  if (wasDbUsed()) {
+    await configureTeardown();
+  }
+});
+afterAll(async () => {
+  if (wasDbUsed()) {
+    const db = await getProjectDb();
+    db.$disconnect();
+  }
+});
+async function loadScenarios(testPath, scenarioName) {
+  const testFileDir = import_node_path.default.parse(testPath);
+  const testFileNameParts = testFileDir.name.split(".");
+  const testFilePath = `${testFileDir.dir}/${testFileNameParts.slice(0, testFileNameParts.length - 1).join(".")}.scenarios`;
+  let allScenarios;
+  let scenario;
+  try {
+    allScenarios = require(testFilePath);
+  } catch (e) {
+    if (isErrorWithCode(e) && e.code !== "MODULE_NOT_FOUND") {
+      throw new Error(`Failed to load scenario: ${e}`);
+    }
+  }
+  if (allScenarios) {
+    if (allScenarios[scenarioName]) {
+      scenario = allScenarios[scenarioName];
+    } else {
+      throw new Error(
+        `UndefinedScenario: There is no scenario named "${scenarioName}" in ${testFilePath}.{js,ts}`
+      );
+    }
+  }
+  return { scenario };
+}
+function isErrorWithCode(error) {
+  return !!error && typeof error === "object" && "code" in error && typeof error.code === "string";
+}
+function isErrorWithMessage(error) {
+  return !!error && typeof error === "object" && "message" in error && typeof error.message === "string";
+}

package/config/jest/api/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "cedarjs-jest-api-preset",
+  "version": "0.0.1",
+  "type": "commonjs",
+  "main": "index.js",
+  "license": "MIT",
+  "types": "./index.d.ts"
+}

package/config/jest/babelPlugins/babel-plugin-redwood-cell.d.ts

@@ -0,0 +1,11 @@
+import type { PluginObj, PluginPass } from '@babel/core';
+import type * as t from '@babel/types';
+interface PluginState extends PluginPass {
+    exportNames: string[];
+    hasDefaultExport: boolean;
+}
+export default function ({ types, }: {
+    types: typeof t;
+}): PluginObj<PluginState>;
+export {};
+//# sourceMappingURL=babel-plugin-redwood-cell.d.ts.map

package/config/jest/babelPlugins/babel-plugin-redwood-cell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin-redwood-cell.d.ts","sourceRoot":"","sources":["../../../../../src/config/jest/babelPlugins/babel-plugin-redwood-cell.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AACxD,OAAO,KAAK,KAAK,CAAC,MAAM,cAAc,CAAA;AAsCtC,UAAU,WAAY,SAAQ,UAAU;IAKtC,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,gBAAgB,EAAE,OAAO,CAAA;CAC1B;AAED,MAAM,CAAC,OAAO,WAAW,EACvB,KAAK,GACN,EAAE;IACD,KAAK,EAAE,OAAO,CAAC,CAAA;CAChB,GAAG,SAAS,CAAC,WAAW,CAAC,CAoHzB"}