@skmdev/prisma-fixtures 0.1.1

package/dist/index.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaFixtures = exports.readFixtureDefinitions = exports.FixtureError = void 0;
+exports.loadFixtures = loadFixtures;
+exports.cleanFixtures = cleanFixtures;
+exports.resetFixtures = resetFixtures;
+const fixture_document_1 = require("./fixture-document");
+const fixture_reference_1 = require("./fixture-reference");
+const fixture_template_1 = require("./fixture-template");
+const cleanup_options_1 = require("./cleanup-options");
+const load_options_1 = require("./load-options");
+const fixture_error_1 = require("./fixture-error");
+const fixture_config_1 = require("./fixture-config");
+var fixture_error_2 = require("./fixture-error");
+Object.defineProperty(exports, "FixtureError", { enumerable: true, get: function () { return fixture_error_2.FixtureError; } });
+exports.readFixtureDefinitions = fixture_document_1.readFixtureDocuments;
+class PrismaFixtures {
+    async load(client) {
+        const config = (0, fixture_config_1.readFixtureConfig)();
+        if (!config.fixtures) {
+            throw new Error('Fixture config must define fixtures');
+        }
+        if (typeof config.client === 'object' && config.client.guard) {
+            throw new Error('Guarded fixture config requires the CLI');
+        }
+        const definitions = (0, fixture_document_1.readFixturePaths)(config.fixtures);
+        const transaction = client?.$transaction;
+        if (typeof transaction !== 'function') {
+            throw new Error('The client must implement $transaction');
+        }
+        return transaction.call(client, (tx) => loadFixtures(tx, definitions, {
+            seed: config.seed,
+            refDate: config.refDate,
+        }), { timeout: config.timeout ?? 60_000 });
+    }
+}
+exports.PrismaFixtures = PrismaFixtures;
+async function loadFixtures(client, definitions, optionsOrWrite, finalWrite) {
+    if (typeof optionsOrWrite === 'function' && finalWrite !== undefined) {
+        throw new Error('Invalid fixture loader arguments');
+    }
+    const options = (0, load_options_1.normalizeLoadOptions)(typeof optionsOrWrite === 'function' ? undefined : optionsOrWrite);
+    const write = typeof optionsOrWrite === 'function' ? optionsOrWrite : finalWrite;
+    const fixtures = await prepareFixtures(client, definitions, write, options);
+    return writeFixtures(fixtures, write);
+}
+async function cleanFixtures(client, options) {
+    const { preserveTables = [] } = (0, cleanup_options_1.normalizeCleanupOptions)(options);
+    if (client === null ||
+        (typeof client !== 'object' && typeof client !== 'function')) {
+        throw new Error('Invalid fixture cleaner arguments');
+    }
+    const execute = client.$executeRawUnsafe;
+    if (typeof execute !== 'function') {
+        throw new Error('Fixture cleaner requires $executeRawUnsafe');
+    }
+    const preservedHex = Buffer.from(JSON.stringify(preserveTables.map((name) => {
+        const [schema, table] = name.split('.');
+        return { schema, table };
+    }))).toString('hex');
+    // PostgreSQL only: config is hex data; catalog identifiers are quoted by PostgreSQL.
+    await execute.call(client, `DO $$
+DECLARE
+  tables text;
+  preserved jsonb := convert_from(decode('${preservedHex}', 'hex'), 'UTF8')::jsonb;
+BEGIN
+  IF EXISTS (
+    SELECT 1
+    FROM jsonb_to_recordset(preserved) AS requested("schema" text, "table" text)
+    WHERE NOT EXISTS (
+      SELECT 1
+      FROM pg_catalog.pg_class AS candidate
+      JOIN pg_catalog.pg_namespace AS namespace ON namespace.oid = candidate.relnamespace
+      WHERE namespace.nspname = requested."schema"
+        AND candidate.relname = requested."table"
+        AND candidate.relkind IN ('r', 'p')
+    )
+  ) THEN
+    RAISE EXCEPTION 'Fixture cleanup preserve table not found';
+  END IF;
+
+  -- TRUNCATE follows inheritance; reject every cleanup/exclusion boundary.
+  IF EXISTS (
+    WITH cleanup_tables AS (
+      SELECT candidate.oid
+      FROM pg_catalog.pg_class AS candidate
+      JOIN pg_catalog.pg_namespace AS namespace ON namespace.oid = candidate.relnamespace
+      WHERE candidate.relkind IN ('r', 'p')
+        AND namespace.nspname <> 'information_schema'
+        AND namespace.nspname !~ '^pg_'
+        AND candidate.relname <> '_prisma_migrations'
+        AND NOT EXISTS (
+          SELECT 1
+          FROM jsonb_to_recordset(preserved) AS requested("schema" text, "table" text)
+          WHERE requested."schema" = namespace.nspname
+            AND requested."table" = candidate.relname
+        )
+    )
+    SELECT 1
+    FROM pg_catalog.pg_inherits AS inheritance
+    WHERE
+      EXISTS (
+        SELECT 1 FROM cleanup_tables WHERE cleanup_tables.oid = inheritance.inhparent
+      ) <>
+      EXISTS (
+        SELECT 1 FROM cleanup_tables WHERE cleanup_tables.oid = inheritance.inhrelid
+      )
+  ) THEN
+    RAISE EXCEPTION 'Fixture cleanup cannot truncate excluded descendant tables';
+  END IF;
+
+  SELECT string_agg(
+    format('%I.%I', schemaname, tablename),
+    ', ' ORDER BY schemaname, tablename
+  )
+  INTO tables
+  FROM pg_catalog.pg_tables
+  WHERE schemaname <> 'information_schema'
+    AND schemaname !~ '^pg_'
+    AND tablename <> '_prisma_migrations'
+    AND NOT EXISTS (
+      SELECT 1
+      FROM jsonb_to_recordset(preserved) AS requested("schema" text, "table" text)
+      WHERE requested."schema" = schemaname
+        AND requested."table" = tablename
+    );
+
+  IF tables IS NOT NULL THEN
+    EXECUTE 'TRUNCATE TABLE ' || tables || ' CONTINUE IDENTITY RESTRICT';
+  END IF;
+END
+$$;`);
+}
+async function resetFixtures(client, definitions, optionsOrWrite, finalWrite) {
+    if (typeof optionsOrWrite === 'function' && finalWrite !== undefined) {
+        throw new Error('Invalid fixture loader arguments');
+    }
+    const options = (0, load_options_1.normalizeResetOptions)(typeof optionsOrWrite === 'function' ? undefined : optionsOrWrite);
+    const write = typeof optionsOrWrite === 'function' ? optionsOrWrite : finalWrite;
+    const fixtures = await prepareFixtures(client, definitions, write, options.load);
+    await cleanFixtures(client, options.cleanup);
+    return writeFixtures(fixtures, write);
+}
+async function writeFixtures(fixtures, write) {
+    const records = Object.create(null);
+    const deferredUpdates = [];
+    for (const { fixture, delegate, processor } of fixtures) {
+        const resolved = (0, fixture_reference_1.resolveFixtureReferences)(fixture.data, records, fixture);
+        if (!(0, fixture_document_1.isFixtureRecord)(resolved))
+            throw new Error('Invalid fixture data');
+        const processed = await (0, fixture_template_1.runFixtureProcessor)(processor, fixture, resolved);
+        const data = (0, fixture_reference_1.applyFixtureConnections)(processed, fixture.connectedFields, fixture);
+        const deferred = Object.fromEntries((fixture.deferredFields ?? []).map((field) => [field, data[field]]));
+        const createData = { ...data };
+        for (const field of fixture.deferredFields ?? [])
+            delete createData[field];
+        let saved;
+        try {
+            saved = write
+                ? await write(fixture, data)
+                : await delegate.create({ data: createData });
+        }
+        catch (error) {
+            throw (0, fixture_error_1.wrapFixtureError)(error, 'FIXTURE_WRITE_FAILED', 'Fixture persistence failed', (0, fixture_document_1.fixtureErrorContext)(fixture, 'writing fixture'));
+        }
+        if (!(0, fixture_document_1.isFixtureRecord)(saved)) {
+            throw (0, fixture_error_1.createFixtureError)('FIXTURE_WRITE_FAILED', 'Fixture writer returned an invalid record', (0, fixture_document_1.fixtureErrorContext)(fixture, 'writing fixture'));
+        }
+        records[fixture.name] = saved;
+        if (fixture.deferredFields?.length) {
+            if (saved.id === undefined) {
+                throw (0, fixture_error_1.createFixtureError)('FIXTURE_WRITE_FAILED', 'Deferred fixture update requires a saved id', (0, fixture_document_1.fixtureErrorContext)(fixture, 'writing fixture'));
+            }
+            deferredUpdates.push({
+                fixture,
+                delegate: delegate,
+                id: saved.id,
+                data: deferred,
+            });
+        }
+    }
+    for (const { fixture, delegate, id, data } of deferredUpdates) {
+        try {
+            const saved = await delegate.update({ where: { id }, data });
+            if (!(0, fixture_document_1.isFixtureRecord)(saved))
+                throw new Error('Invalid updated record');
+            records[fixture.name] = saved;
+        }
+        catch (error) {
+            throw (0, fixture_error_1.wrapFixtureError)(error, 'FIXTURE_WRITE_FAILED', 'Fixture persistence failed', (0, fixture_document_1.fixtureErrorContext)(fixture, 'updating fixture'));
+        }
+    }
+    return records;
+}
+async function prepareFixtures(client, definitions, write, options) {
+    if (client === null ||
+        (typeof client !== 'object' && typeof client !== 'function') ||
+        (write !== undefined && typeof write !== 'function')) {
+        throw new Error('Invalid fixture loader arguments');
+    }
+    if (!Array.isArray(definitions) ||
+        definitions.length > fixture_document_1.MAX_FIXTURE_DEFINITIONS) {
+        throw new Error('Invalid fixture definitions');
+    }
+    const names = new Set();
+    for (const definition of definitions) {
+        (0, fixture_document_1.assertFixtureDefinition)(definition);
+        if (names.has(definition.name))
+            throw new Error('Duplicate fixture name');
+        names.add(definition.name);
+    }
+    const runtime = new Map();
+    for (const fixture of definitions) {
+        const delegate = write ? undefined : resolveDelegate(client, fixture.entity);
+        if (fixture.deferredFields?.length && (write || !delegate?.update)) {
+            throw new Error('Deferred fields require a client update delegate');
+        }
+        let processor;
+        if (fixture.processor) {
+            try {
+                processor = await (0, fixture_template_1.loadFixtureProcessor)(fixture.processor);
+            }
+            catch (error) {
+                throw (0, fixture_error_1.wrapFixtureError)(error, 'FIXTURE_PROCESSOR_FAILED', 'Fixture processor could not be loaded', (0, fixture_document_1.fixtureErrorContext)(fixture, 'loading processor'));
+            }
+        }
+        runtime.set(fixture.name, {
+            delegate,
+            ...(processor ? { processor } : {}),
+        });
+    }
+    const randomizer = await (0, fixture_template_1.createFixtureRandomizer)(options.seed);
+    const rendered = [];
+    for (const fixture of definitions) {
+        const result = {
+            ...fixture,
+            data: await (0, fixture_template_1.renderFixtureTemplates)(fixture, randomizer, options.refDate),
+        };
+        (0, fixture_document_1.inheritFixtureSource)(fixture, result);
+        rendered.push(result);
+    }
+    return (0, fixture_reference_1.prepareFixtureReferences)(rendered, randomizer).map((fixture) => ({
+        fixture,
+        ...runtime.get(fixture.name),
+    }));
+}
+function resolveDelegate(client, entity) {
+    const clientRecord = client;
+    const delegateName = entity[0].toLowerCase() + entity.slice(1);
+    const candidate = clientRecord[entity] ?? clientRecord[delegateName];
+    if (candidate === null ||
+        (typeof candidate !== 'object' && typeof candidate !== 'function') ||
+        typeof candidate.create !== 'function') {
+        throw new Error(`Fixture model delegate not found: ${entity}`);
+    }
+    return candidate;
+}

package/dist/load-options.d.ts

@@ -0,0 +1,11 @@
+import { type FixtureCleanupOptions } from './cleanup-options';
+export type FixtureLoadOptions = {
+    seed?: number;
+    refDate?: string;
+};
+export type FixtureResetOptions = FixtureCleanupOptions & FixtureLoadOptions;
+export declare function normalizeLoadOptions(value?: unknown): FixtureLoadOptions;
+export declare function normalizeResetOptions(value?: unknown): {
+    load: FixtureLoadOptions;
+    cleanup: FixtureCleanupOptions;
+};

package/dist/load-options.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeLoadOptions = normalizeLoadOptions;
+exports.normalizeResetOptions = normalizeResetOptions;
+const cleanup_options_1 = require("./cleanup-options");
+const fixture_document_1 = require("./fixture-document");
+const fixture_error_1 = require("./fixture-error");
+function normalizeLoadOptions(value = {}) {
+    if (!(0, fixture_document_1.isFixtureRecord)(value) ||
+        Object.keys(value).some((key) => !['seed', 'refDate'].includes(key))) {
+        throw invalidLoadOptions();
+    }
+    const { seed, refDate } = value;
+    if ((seed !== undefined &&
+        (typeof seed !== 'number' ||
+            !Number.isInteger(seed) ||
+            seed < 0 ||
+            seed > 0xffff_ffff)) ||
+        (refDate !== undefined && !isCanonicalReferenceDate(refDate))) {
+        throw invalidLoadOptions();
+    }
+    return {
+        ...(seed === undefined ? {} : { seed }),
+        ...(refDate === undefined ? {} : { refDate }),
+    };
+}
+function normalizeResetOptions(value = {}) {
+    if (!(0, fixture_document_1.isFixtureRecord)(value) ||
+        Object.keys(value).some((key) => !['seed', 'refDate', 'preserveTables'].includes(key))) {
+        throw invalidLoadOptions();
+    }
+    return {
+        load: normalizeLoadOptions({ seed: value.seed, refDate: value.refDate }),
+        cleanup: (0, cleanup_options_1.normalizeCleanupOptions)({ preserveTables: value.preserveTables }),
+    };
+}
+function isCanonicalReferenceDate(value) {
+    if (typeof value !== 'string' ||
+        !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value)) {
+        return false;
+    }
+    const parsed = new Date(value);
+    return !Number.isNaN(parsed.valueOf()) && parsed.toISOString() === value;
+}
+function invalidLoadOptions() {
+    return (0, fixture_error_1.createFixtureError)('FIXTURE_OPTIONS_INVALID', 'Invalid fixture load options', { stage: 'validating options' });
+}

package/dist/prisma-config.d.ts

@@ -0,0 +1,8 @@
+import { type FixturePreservedTable } from './cleanup-options';
+type PrismaDefaults = {
+    module: string;
+    databaseUrl?: string;
+    preserveTables: FixturePreservedTable[];
+};
+export declare function loadPrismaDefaults(configRoot: string, requireFromCwd: NodeRequire, databaseUrlOverride?: string): Promise<PrismaDefaults>;
+export {};

package/dist/prisma-config.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPrismaDefaults = loadPrismaDefaults;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const cleanup_options_1 = require("./cleanup-options");
+async function loadPrismaDefaults(configRoot, requireFromCwd, databaseUrlOverride) {
+    const requireFromPrisma = (0, node_module_1.createRequire)(requireFromCwd.resolve('prisma/package.json'));
+    const { loadConfigFromFile } = requireFromPrisma('@prisma/config');
+    const previousUrl = process.env.DATABASE_URL;
+    if (databaseUrlOverride !== undefined) {
+        process.env.DATABASE_URL = databaseUrlOverride;
+    }
+    let loaded;
+    try {
+        loaded = await loadConfigFromFile({ configRoot });
+    }
+    finally {
+        if (databaseUrlOverride !== undefined) {
+            if (previousUrl === undefined)
+                delete process.env.DATABASE_URL;
+            else
+                process.env.DATABASE_URL = previousUrl;
+        }
+    }
+    if (!loaded.resolvedPath || !loaded.config || loaded.error) {
+        throw new Error('Prisma config could not be loaded');
+    }
+    const schemaPath = loaded.config.schema ?? defaultSchema(configRoot);
+    const source = generatedClient(schemaPath);
+    return {
+        module: runtimeClient(source, configRoot, requireFromCwd),
+        databaseUrl: loaded.config.datasource?.url,
+        preserveTables: (0, cleanup_options_1.normalizeCleanupOptions)({
+            preserveTables: loaded.config.tables?.external ?? [],
+        }).preserveTables ?? [],
+    };
+}
+function defaultSchema(root) {
+    for (const name of ['prisma/schema.prisma', 'schema.prisma']) {
+        const file = node_path_1.default.join(root, name);
+        if (node_fs_1.default.existsSync(file))
+            return file;
+    }
+    throw new Error('Prisma schema not found');
+}
+function generatedClient(schemaPath) {
+    const files = [];
+    function visit(target) {
+        if (node_fs_1.default.statSync(target).isDirectory()) {
+            for (const entry of node_fs_1.default.readdirSync(target).sort())
+                visit(node_path_1.default.join(target, entry));
+        }
+        else if (target.endsWith('.prisma')) {
+            files.push(target);
+        }
+    }
+    visit(schemaPath);
+    const clients = [];
+    for (const file of files) {
+        const source = node_fs_1.default
+            .readFileSync(file, 'utf8')
+            .replace(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, '');
+        for (const match of source.matchAll(/^\s*generator\s+\w+\s*\{([^}]*)\}/gm)) {
+            const field = (name) => match[1].match(new RegExp(`^\\s*${name}\\s*=\\s*"([^"\\n]*)"`, 'm'))?.[1];
+            if (field('provider') !== 'prisma-client')
+                continue;
+            const output = field('output');
+            const extension = field('generatedFileExtension') ?? 'ts';
+            if (!output ||
+                !['ts', 'mts', 'cts', 'js', 'mjs', 'cjs'].includes(extension)) {
+                throw new Error('Prisma client output must be a static supported path');
+            }
+            clients.push(node_path_1.default.resolve(node_path_1.default.dirname(file), output, `client.${extension}`));
+        }
+    }
+    if (clients.length !== 1)
+        throw new Error('Expected one prisma-client generator');
+    if (!node_fs_1.default.existsSync(clients[0])) {
+        throw new Error('Generated Prisma client not found; run prisma generate');
+    }
+    return clients[0];
+}
+function runtimeClient(source, configRoot, requireFromCwd) {
+    const extension = node_path_1.default.extname(source);
+    if (extension !== '.ts' && extension !== '.cts')
+        return source;
+    if (require.extensions[extension])
+        return source;
+    const tsconfig = node_path_1.default.join(configRoot, 'tsconfig.json');
+    if (node_fs_1.default.existsSync(tsconfig)) {
+        const ts = requireFromCwd('typescript');
+        const parsed = ts.readConfigFile(tsconfig, ts.sys.readFile);
+        const { rootDir, outDir } = parsed.config?.compilerOptions ?? {};
+        if (typeof rootDir === 'string' && typeof outDir === 'string') {
+            const relative = node_path_1.default.relative(node_path_1.default.resolve(configRoot, rootDir), source);
+            if (relative &&
+                !relative.startsWith('..') &&
+                !node_path_1.default.isAbsolute(relative)) {
+                const emitted = node_path_1.default.resolve(configRoot, outDir, relative.replace(/\.(?:ts|cts)$/, extension === '.cts' ? '.cjs' : '.js'));
+                if (node_fs_1.default.existsSync(emitted))
+                    return emitted;
+            }
+        }
+    }
+    return source;
+}

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@skmdev/prisma-fixtures",
+  "version": "0.1.1",
+  "description": "YAML and JSON fixtures with references, templates and processors for Prisma.",
+  "license": "MIT",
+  "author": "skmdev <skmdev29@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/skmdev/prisma-fixtures.git"
+  },
+  "homepage": "https://github.com/skmdev/prisma-fixtures#readme",
+  "bugs": "https://github.com/skmdev/prisma-fixtures/issues",
+  "keywords": [
+    "prisma",
+    "fixtures",
+    "yaml",
+    "seed",
+    "testing"
+  ],
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./schema.json": "./schema/fixture.schema.json"
+  },
+  "bin": {
+    "prisma-fixtures": "dist/cli.js",
+    "prisma-fixtures-generator": "dist/generator.js"
+  },
+  "files": [
+    "dist",
+    "schema/fixture.schema.json",
+    "README.md",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node -e \"for (const file of Object.values(require('./package.json').bin)) require('node:fs').chmodSync(file, 0o755)\"",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "prettier --check .",
+    "lint:fixtures": "npm run build && npm exec --yes --package=. -- node test/lint-examples.cjs",
+    "format": "prettier --write .",
+    "test": "npm run build && node --test test/*.test.cjs",
+    "test:integration": "node test/integration.cjs",
+    "test:examples": "node test/integration.cjs --examples",
+    "verify": "npm run lint && npm run typecheck && npm test && npm run lint:fixtures",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@faker-js/faker": "10.6.0",
+    "@prisma/generator-helper": "7.10.0",
+    "ajv": "8.20.0",
+    "ejs": "6.0.1",
+    "yaml": "2.9.1"
+  },
+  "devDependencies": {
+    "@prisma/adapter-pg": "7.10.0",
+    "@prisma/client": "7.10.0",
+    "@types/ejs": "3.1.5",
+    "@types/node": "22.19.15",
+    "prettier": "3.8.3",
+    "prisma": "7.10.0",
+    "typescript": "5.9.3"
+  },
+  "overrides": {
+    "@prisma/config": {
+      "deepmerge-ts": "8.0.0"
+    },
+    "prisma": {
+      "mysql2": "3.24.4"
+    }
+  }
+}

package/schema/fixture.schema.json

@@ -0,0 +1,119 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Prisma Fixtures document",
+  "description": "A YAML or JSON fixture document for one Prisma entity.",
+  "type": "object",
+  "required": ["entity", "items"],
+  "additionalProperties": false,
+  "properties": {
+    "entity": {
+      "$ref": "#/definitions/entityName"
+    },
+    "parameters": {
+      "description": "Document-local values available to <{parameter.path}> templates.",
+      "allOf": [
+        {
+          "$ref": "#/definitions/safeObject"
+        }
+      ],
+      "default": {}
+    },
+    "locale": {
+      "description": "Faker locale name; English is used as a fallback.",
+      "type": "string",
+      "minLength": 1
+    },
+    "processor": {
+      "description": "Processor module path, resolved relative to this fixture document.",
+      "type": "string",
+      "minLength": 1
+    },
+    "connectedFields": {
+      "description": "Fields whose fixture references are converted to Prisma connect inputs.",
+      "type": "array",
+      "uniqueItems": true,
+      "items": {
+        "$ref": "#/definitions/fieldName"
+      }
+    },
+    "deferredFields": {
+      "description": "Scalar fields written by Prisma update after all fixture creates; requires a saved id and no custom writer.",
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": {
+        "$ref": "#/definitions/fieldName"
+      }
+    },
+    "items": {
+      "description": "Fixture records keyed by a name or inclusive numeric range such as user{1..3}.",
+      "type": "object",
+      "propertyNames": {
+        "$ref": "#/definitions/itemName"
+      },
+      "additionalProperties": {
+        "$ref": "#/definitions/safeObject"
+      }
+    }
+  },
+  "definitions": {
+    "entityName": {
+      "description": "Prisma model/delegate name.",
+      "type": "string",
+      "pattern": "^[A-Za-z][A-Za-z0-9_-]{0,127}$"
+    },
+    "fieldName": {
+      "description": "Prisma relation field name.",
+      "type": "string",
+      "pattern": "^[A-Za-z][A-Za-z0-9_]*$",
+      "not": {
+        "enum": ["__proto__", "prototype", "constructor"]
+      }
+    },
+    "itemName": {
+      "description": "Fixture name or inclusive numeric range.",
+      "type": "string",
+      "pattern": "^(?:[A-Za-z][A-Za-z0-9_-]{0,127}|[A-Za-z][A-Za-z0-9_-]{0,126}\\{[0-9]+\\.\\.[0-9]+\\})$",
+      "not": {
+        "enum": ["__proto__", "prototype", "constructor"]
+      }
+    },
+    "safeObject": {
+      "type": "object",
+      "propertyNames": {
+        "not": {
+          "enum": ["__proto__", "prototype", "constructor"]
+        }
+      },
+      "additionalProperties": {
+        "$ref": "#/definitions/jsonValue"
+      }
+    },
+    "jsonValue": {
+      "description": "A JSON-compatible value; template expressions remain ordinary strings.",
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "type": "number"
+        },
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "null"
+        },
+        {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/jsonValue"
+          }
+        },
+        {
+          "$ref": "#/definitions/safeObject"
+        }
+      ]
+    }
+  }
+}