blockmine 1.0.0 → 1.0.1

package/backend/node_modules/@prisma/get-platform/dist/getNodeAPIName.d.ts

@@ -0,0 +1,8 @@
+import { BinaryTarget } from './binaryTargets';
+/**
+ * Gets Node-API Library name depending on the binary target
+ * @param binaryTarget
+ * @param type  `fs` gets name used on the file system, `url` gets the name required to download the library from S3
+ * @returns
+ */
+export declare function getNodeAPIName(binaryTarget: BinaryTarget, type: 'url' | 'fs'): string;

package/backend/node_modules/@prisma/get-platform/dist/getNodeAPIName.js

@@ -0,0 +1,25 @@
+"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 getNodeAPIName_exports = {};
+__export(getNodeAPIName_exports, {
+  getNodeAPIName: () => import_chunk_2U36ISZO.getNodeAPIName
+});
+module.exports = __toCommonJS(getNodeAPIName_exports);
+var import_chunk_2U36ISZO = require("./chunk-2U36ISZO.js");
+var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");

package/backend/node_modules/@prisma/get-platform/dist/getPlatform.d.ts

@@ -0,0 +1,105 @@
+/// <reference types="node" />
+import { BinaryTarget } from './binaryTargets';
+declare const supportedLibSSLVersions: readonly ["1.0.x", "1.1.x", "3.0.x"];
+export type Arch = 'x32' | 'x64' | 'arm' | 'arm64' | 's390' | 's390x' | 'mipsel' | 'ia32' | 'mips' | 'ppc' | 'ppc64';
+export type DistroInfo = {
+    /**
+     * The original distro is the Linux distro name detected via its release file.
+     * E.g., on Arch Linux, the original distro is `arch`. On Linux Alpine, the original distro is `alpine`.
+     */
+    originalDistro?: string;
+    /**
+     * The family distro is the Linux distro name that is used to determine Linux families based on the same base distro, and likely using the same package manager.
+     * E.g., both Ubuntu and Debian belong to the `debian` family of distros, and thus rely on the same package manager (`apt`).
+     */
+    familyDistro?: string;
+    /**
+     * The target distro is the Linux distro associated with the Prisma Engines.
+     * E.g., on Arch Linux, Debian, and Ubuntu, the target distro is `debian`. On Linux Alpine, the target distro is `musl`.
+     */
+    targetDistro?: 'rhel' | 'debian' | 'musl' | 'arm' | 'nixos' | 'freebsd11' | 'freebsd12' | 'freebsd13' | 'freebsd14' | 'freebsd15';
+};
+type GetOsResultLinux = {
+    platform: 'linux';
+    arch: Arch;
+    archFromUname: string | undefined;
+    /**
+     * Starting from version 3.0, OpenSSL is basically adopting semver, and will be API and ABI compatible within a major version.
+     */
+    libssl?: (typeof supportedLibSSLVersions)[number];
+} & DistroInfo;
+export type GetOSResult = {
+    platform: Omit<NodeJS.Platform, 'linux'>;
+    arch: Arch;
+    targetDistro?: DistroInfo['targetDistro'];
+    familyDistro?: never;
+    originalDistro?: never;
+    archFromUname?: never;
+    libssl?: never;
+} | GetOsResultLinux;
+/**
+ * For internal use only. This public export will be eventually removed in favor of `getPlatformWithOSResult`.
+ */
+export declare function getos(): Promise<GetOSResult>;
+export declare function parseDistro(osReleaseInput: string): DistroInfo;
+export declare function resolveDistro(): Promise<DistroInfo>;
+/**
+ * Parse the OpenSSL version from the output of the openssl binary, e.g.
+ * "OpenSSL 3.0.2 15 Mar 2022 (Library: OpenSSL 3.0.2 15 Mar 2022)" -> "3.0.x"
+ */
+export declare function parseOpenSSLVersion(input: string): GetOsResultLinux['libssl'] | undefined;
+/**
+ * Parse the OpenSSL version from the output of the libssl.so file, e.g.
+ * "libssl.so.3" -> "3.0.x"
+ */
+export declare function parseLibSSLVersion(input: string): GetOsResultLinux['libssl'];
+type ComputeLibSSLSpecificPathsParams = {
+    arch: Arch;
+    archFromUname: Awaited<ReturnType<typeof getArchFromUname>>;
+    familyDistro: DistroInfo['familyDistro'];
+};
+export declare function computeLibSSLSpecificPaths(args: ComputeLibSSLSpecificPathsParams): string[];
+type GetOpenSSLVersionResult = {
+    libssl: GetOsResultLinux['libssl'];
+    strategy: 'libssl-specific-path' | 'ldconfig' | 'openssl-binary';
+} | {
+    libssl?: never;
+    strategy?: never;
+};
+/**
+ * On Linux, returns the libssl version excluding the patch version, e.g. "1.1.x".
+ * Reading the version from the libssl.so file is more reliable than reading it from the openssl binary.
+ * Older versions of libssl are preferred, e.g. "1.0.x" over "1.1.x", because of Vercel serverless
+ * having different build and runtime environments, with the runtime environment having an old version
+ * of libssl, and the build environment having both that old version and a newer version of libssl installed.
+ * Because of https://github.com/prisma/prisma/issues/17499, we explicitly filter out libssl 0.x.
+ *
+ * This function never throws.
+ */
+export declare function getSSLVersion(libsslSpecificPaths: string[]): Promise<GetOpenSSLVersionResult>;
+/**
+ * Get the binary target for the current platform, e.g. `linux-musl-arm64-openssl-3.0.x` for Linux Alpine on arm64.
+ */
+export declare function getBinaryTargetForCurrentPlatform(): Promise<BinaryTarget>;
+export type PlatformInfo = GetOSResult & {
+    binaryTarget: BinaryTarget;
+};
+/**
+ * Get the binary target and other system information (e.g., the libssl version to look for) for the current platform.
+ */
+export declare function getPlatformInfo(): Promise<PlatformInfo>;
+export declare function getPlatformInfoMemoized(): Promise<PlatformInfo & {
+    memoized: boolean;
+}>;
+/**
+ * This function is only exported for testing purposes.
+ */
+export declare function getBinaryTargetForCurrentPlatformInternal(args: GetOSResult): BinaryTarget;
+/**
+ * Returns the architecture of a system from the output of `uname -m` (whose format is different than `process.arch`).
+ * This function never throws.
+ * TODO: deprecate this function in favor of `os.machine()` once either Node v16.18.0 or v18.9.0 becomes the minimum
+ * supported Node.js version for Prisma.
+ */
+export declare function getArchFromUname(): Promise<string | undefined>;
+export {};

package/backend/node_modules/@prisma/get-platform/dist/getPlatform.js

@@ -0,0 +1,38 @@
+"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 getPlatform_exports = {};
+__export(getPlatform_exports, {
+  computeLibSSLSpecificPaths: () => import_chunk_YDM7ULQH.computeLibSSLSpecificPaths,
+  getArchFromUname: () => import_chunk_YDM7ULQH.getArchFromUname,
+  getBinaryTargetForCurrentPlatform: () => import_chunk_YDM7ULQH.getBinaryTargetForCurrentPlatform,
+  getBinaryTargetForCurrentPlatformInternal: () => import_chunk_YDM7ULQH.getBinaryTargetForCurrentPlatformInternal,
+  getPlatformInfo: () => import_chunk_YDM7ULQH.getPlatformInfo,
+  getPlatformInfoMemoized: () => import_chunk_YDM7ULQH.getPlatformInfoMemoized,
+  getSSLVersion: () => import_chunk_YDM7ULQH.getSSLVersion,
+  getos: () => import_chunk_YDM7ULQH.getos,
+  parseDistro: () => import_chunk_YDM7ULQH.parseDistro,
+  parseLibSSLVersion: () => import_chunk_YDM7ULQH.parseLibSSLVersion,
+  parseOpenSSLVersion: () => import_chunk_YDM7ULQH.parseOpenSSLVersion,
+  resolveDistro: () => import_chunk_YDM7ULQH.resolveDistro
+});
+module.exports = __toCommonJS(getPlatform_exports);
+var import_chunk_YDM7ULQH = require("./chunk-YDM7ULQH.js");
+var import_chunk_FWMN4WME = require("./chunk-FWMN4WME.js");
+var import_chunk_YVXCXD3A = require("./chunk-YVXCXD3A.js");
+var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");

package/backend/node_modules/@prisma/get-platform/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { assertNodeAPISupported } from './assertNodeAPISupported';
+export { type BinaryTarget, binaryTargets } from './binaryTargets';
+export { getNodeAPIName } from './getNodeAPIName';
+export type { PlatformInfo } from './getPlatform';
+export { getBinaryTargetForCurrentPlatform, getos, getPlatformInfo } from './getPlatform';
+export { link } from './link';
+export * from './test-utils';

package/backend/node_modules/@prisma/get-platform/dist/index.js

@@ -0,0 +1,43 @@
+"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 dist_exports = {};
+__export(dist_exports, {
+  assertNodeAPISupported: () => import_chunk_O5EOXX3N.assertNodeAPISupported,
+  binaryTargets: () => import_chunk_7MLUNQIZ.binaryTargets,
+  getBinaryTargetForCurrentPlatform: () => import_chunk_YDM7ULQH.getBinaryTargetForCurrentPlatform,
+  getNodeAPIName: () => import_chunk_2U36ISZO.getNodeAPIName,
+  getPlatformInfo: () => import_chunk_YDM7ULQH.getPlatformInfo,
+  getos: () => import_chunk_YDM7ULQH.getos,
+  jestConsoleContext: () => import_chunk_M5NKJZ76.jestConsoleContext,
+  jestContext: () => import_chunk_M5NKJZ76.jestContext,
+  jestProcessContext: () => import_chunk_M5NKJZ76.jestProcessContext,
+  link: () => import_chunk_D7S5FGQN.link
+});
+module.exports = __toCommonJS(dist_exports);
+var import_chunk_6HZWON4S = require("./chunk-6HZWON4S.js");
+var import_chunk_M5NKJZ76 = require("./chunk-M5NKJZ76.js");
+var import_chunk_O5EOXX3N = require("./chunk-O5EOXX3N.js");
+var import_chunk_2U36ISZO = require("./chunk-2U36ISZO.js");
+var import_chunk_YDM7ULQH = require("./chunk-YDM7ULQH.js");
+var import_chunk_D7S5FGQN = require("./chunk-D7S5FGQN.js");
+var import_chunk_FWMN4WME = require("./chunk-FWMN4WME.js");
+var import_chunk_YVXCXD3A = require("./chunk-YVXCXD3A.js");
+var import_chunk_7MLUNQIZ = require("./chunk-7MLUNQIZ.js");
+var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");
+(0, import_chunk_7MLUNQIZ.init_binaryTargets)();

package/backend/node_modules/@prisma/get-platform/dist/link.d.ts

@@ -0,0 +1 @@
+export declare function link(url: any): string;

package/backend/node_modules/@prisma/get-platform/dist/link.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 __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 link_exports = {};
+__export(link_exports, {
+  link: () => import_chunk_D7S5FGQN.link
+});
+module.exports = __toCommonJS(link_exports);
+var import_chunk_D7S5FGQN = require("./chunk-D7S5FGQN.js");
+var import_chunk_YVXCXD3A = require("./chunk-YVXCXD3A.js");
+var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");

package/backend/node_modules/@prisma/get-platform/dist/logger.d.ts

@@ -0,0 +1,8 @@
+export declare const tags: {
+    warn: string;
+};
+export declare const should: {
+    warn: () => boolean;
+};
+export declare function log(...data: any[]): void;
+export declare function warn(message: any, ...optionalParams: any[]): void;

package/backend/node_modules/@prisma/get-platform/dist/logger.js

@@ -0,0 +1,29 @@
+"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 logger_exports = {};
+__export(logger_exports, {
+  log: () => import_chunk_FWMN4WME.log,
+  should: () => import_chunk_FWMN4WME.should,
+  tags: () => import_chunk_FWMN4WME.tags,
+  warn: () => import_chunk_FWMN4WME.warn
+});
+module.exports = __toCommonJS(logger_exports);
+var import_chunk_FWMN4WME = require("./chunk-FWMN4WME.js");
+var import_chunk_YVXCXD3A = require("./chunk-YVXCXD3A.js");
+var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");

package/backend/node_modules/@prisma/get-platform/dist/test-utils/binaryTargetRegex.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This regex matches all supported binary target names in a given string.
+ *
+ * Platform names are sorted by their lengths in descending order to ensure that
+ * the longest substring is always matched (e.g., "darwin-arm64" is matched as a
+ * whole instead of "darwin" and "arm" separately)
+ */
+export declare const binaryTargetRegex: RegExp;

package/backend/node_modules/@prisma/get-platform/dist/test-utils/binaryTargetRegex.js

@@ -0,0 +1,27 @@
+"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 binaryTargetRegex_exports = {};
+__export(binaryTargetRegex_exports, {
+  binaryTargetRegex: () => import_chunk_B23KD6U3.binaryTargetRegex
+});
+module.exports = __toCommonJS(binaryTargetRegex_exports);
+var import_chunk_B23KD6U3 = require("../chunk-B23KD6U3.js");
+var import_chunk_7MLUNQIZ = require("../chunk-7MLUNQIZ.js");
+var import_chunk_2ESYSVXG = require("../chunk-2ESYSVXG.js");
+(0, import_chunk_B23KD6U3.init_binaryTargetRegex)();

package/backend/node_modules/@prisma/get-platform/dist/test-utils/index.d.ts

@@ -0,0 +1 @@
+export { type BaseContext, jestConsoleContext, jestContext, jestProcessContext } from './jestContext';

package/backend/node_modules/@prisma/get-platform/dist/test-utils/index.js

@@ -0,0 +1,28 @@
+"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 test_utils_exports = {};
+__export(test_utils_exports, {
+  jestConsoleContext: () => import_chunk_M5NKJZ76.jestConsoleContext,
+  jestContext: () => import_chunk_M5NKJZ76.jestContext,
+  jestProcessContext: () => import_chunk_M5NKJZ76.jestProcessContext
+});
+module.exports = __toCommonJS(test_utils_exports);
+var import_chunk_6HZWON4S = require("../chunk-6HZWON4S.js");
+var import_chunk_M5NKJZ76 = require("../chunk-M5NKJZ76.js");
+var import_chunk_2ESYSVXG = require("../chunk-2ESYSVXG.js");

package/backend/node_modules/@prisma/get-platform/dist/test-utils/jestContext.d.ts

@@ -0,0 +1,108 @@
+/// <reference types="jest" />
+import type { ExecaChildProcess } from 'execa';
+import type { FSJetpack } from 'fs-jetpack/types';
+/**
+ * Base test context.
+ */
+export type BaseContext = {
+    tmpDir: string;
+    fs: FSJetpack;
+    mocked: {
+        cwd: string;
+    };
+    /**
+     * Set up the temporary directory based on the contents of some fixture.
+     */
+    fixture: (name: string) => void;
+    /**
+     * Spawn the Prisma cli using the temporary directory as the CWD.
+     *
+     * @remarks
+     *
+     * For this to work the source must be built
+     */
+    cli: (...input: string[]) => ExecaChildProcess<string>;
+    printDir(dir: string, extensions: string[]): void;
+    /**
+     * JavaScript-friendly implementation of the `tree` command. It skips the `node_modules` directory.
+     * @param itemPath The path to start the tree from, defaults to the root of the temporary directory
+     * @param indent How much to indent each level of the tree, defaults to ''
+     * @returns String representation of the directory tree
+     */
+    tree: (itemPath?: string, indent?: string) => void;
+};
+/**
+ * Create test context to use in tests. Provides the following:
+ *
+ * - A temporary directory
+ * - an fs-jetpack instance bound to the temporary directory
+ * - Mocked process.cwd via Node process.chdir
+ * - Fixture loader for bootstrapping the temporary directory with content
+ */
+export declare const jestContext: {
+    new: (ctx?: BaseContext) => {
+        add<NewContext>(contextContributor: ContextContributor<BaseContext, NewContext>): {
+            add<NewContext_1>(contextContributor: ContextContributor<BaseContext & NewContext, NewContext_1>): {
+                add<NewContext_2>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1, NewContext_2>): {
+                    add<NewContext_3>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2, NewContext_3>): {
+                        add<NewContext_4>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3, NewContext_4>): {
+                            add<NewContext_5>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4, NewContext_5>): {
+                                add<NewContext_6>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5, NewContext_6>): {
+                                    add<NewContext_7>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6, NewContext_7>): {
+                                        add<NewContext_8>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6 & NewContext_7, NewContext_8>): {
+                                            add<NewContext_9>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6 & NewContext_7 & NewContext_8, NewContext_9>): {
+                                                add<NewContext_10>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6 & NewContext_7 & NewContext_8 & NewContext_9, NewContext_10>): any;
+                                                assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6 & NewContext_7 & NewContext_8 & NewContext_9;
+                                            };
+                                            assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6 & NewContext_7 & NewContext_8;
+                                        };
+                                        assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6 & NewContext_7;
+                                    };
+                                    assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6;
+                                };
+                                assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5;
+                            };
+                            assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4;
+                        };
+                        assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3;
+                    };
+                    assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2;
+                };
+                assemble(): BaseContext & NewContext & NewContext_1;
+            };
+            assemble(): BaseContext & NewContext;
+        };
+        assemble(): BaseContext;
+    };
+};
+/**
+ * Factory for creating a context contributor possibly configured in some special way.
+ */
+type ContextContributorFactory<Settings, Context, NewContext> = Settings extends {} ? () => ContextContributor<Context, NewContext> : (settings: Settings) => ContextContributor<Context, NewContext>;
+/**
+ * A function that provides additional test context.
+ */
+type ContextContributor<Context, NewContext> = (ctx: Context) => Context & NewContext;
+/**
+ * Test context contributor. Mocks console.error with a Jest spy before each test.
+ */
+type ConsoleContext = {
+    mocked: {
+        'console.error': jest.SpyInstance;
+        'console.log': jest.SpyInstance;
+        'console.info': jest.SpyInstance;
+        'console.warn': jest.SpyInstance;
+    };
+};
+export declare const jestConsoleContext: ContextContributorFactory<{}, BaseContext, ConsoleContext>;
+/**
+ * Test context contributor. Mocks process.std(out|err).write with a Jest spy before each test.
+ */
+type ProcessContext = {
+    mocked: {
+        'process.stderr.write': jest.SpyInstance;
+        'process.stdout.write': jest.SpyInstance;
+    };
+};
+export declare const jestProcessContext: ContextContributorFactory<{}, BaseContext, ProcessContext>;
+export {};

package/backend/node_modules/@prisma/get-platform/dist/test-utils/jestContext.js

@@ -0,0 +1,27 @@
+"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 jestContext_exports = {};
+__export(jestContext_exports, {
+  jestConsoleContext: () => import_chunk_M5NKJZ76.jestConsoleContext,
+  jestContext: () => import_chunk_M5NKJZ76.jestContext,
+  jestProcessContext: () => import_chunk_M5NKJZ76.jestProcessContext
+});
+module.exports = __toCommonJS(jestContext_exports);
+var import_chunk_M5NKJZ76 = require("../chunk-M5NKJZ76.js");
+var import_chunk_2ESYSVXG = require("../chunk-2ESYSVXG.js");