@skmdev/prisma-fixtures 0.1.1

package/dist/fixture-schema.d.ts

@@ -0,0 +1,10 @@
+import type { GeneratorOptions } from '@prisma/generator-helper';
+type Dmmf = GeneratorOptions['dmmf'];
+type JsonSchema = Record<string, unknown>;
+type FixtureSchema = JsonSchema & {
+    properties: Record<string, JsonSchema>;
+    definitions: Record<string, JsonSchema>;
+    allOf?: JsonSchema[];
+};
+export declare function buildFixtureSchema(dmmf: Dmmf): FixtureSchema;
+export {};

package/dist/fixture-schema.js

@@ -0,0 +1,243 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFixtureSchema = buildFixtureSchema;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const baseFixtureSchema = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(__dirname, '../schema/fixture.schema.json'), 'utf8'));
+const dynamicString = () => ({
+    type: 'string',
+    pattern: '(?:^@(?!@)|<%|\\{\\{|<\\{|\\(\\$current(?:[+*/-][0-9]+)?\\))',
+});
+const pointer = (value) => value.replaceAll('~', '~0').replaceAll('/', '~1');
+function buildFixtureSchema(dmmf) {
+    const schema = structuredClone(baseFixtureSchema);
+    const definitions = schema.definitions;
+    const inputs = new Map();
+    const inputsByName = new Map();
+    const enums = new Map();
+    const enumsByName = new Map();
+    const rootRelations = new Map();
+    const addInputs = (namespace, values) => {
+        for (const input of values) {
+            const info = { input, namespace };
+            inputs.set(`${namespace}:${input.name}`, info);
+            if (!inputsByName.has(input.name))
+                inputsByName.set(input.name, info);
+        }
+    };
+    addInputs('model', dmmf.schema.inputObjectTypes.model ?? []);
+    addInputs('prisma', dmmf.schema.inputObjectTypes.prisma ?? []);
+    const addEnums = (namespace, values) => {
+        for (const enumType of values) {
+            const info = { enumType, namespace };
+            enums.set(`${namespace}:${enumType.name}`, info);
+            if (!enumsByName.has(enumType.name))
+                enumsByName.set(enumType.name, info);
+        }
+    };
+    addEnums('model', dmmf.schema.enumTypes.model ?? []);
+    addEnums('prisma', dmmf.schema.enumTypes.prisma);
+    for (const model of dmmf.datamodel.models) {
+        const fields = new Map(model.fields
+            .filter((field) => field.kind === 'object')
+            .map((field) => [field.name, field.isList]));
+        rootRelations.set(`${model.name}CreateInput`, fields);
+        rootRelations.set(`${model.name}UncheckedCreateInput`, fields);
+    }
+    const connectionRecord = () => {
+        const name = 'PrismaFixtureConnectionRecord';
+        if (!(name in definitions)) {
+            definitions[name] = {
+                allOf: [
+                    internalRef('safeObject'),
+                    {
+                        type: 'object',
+                        required: ['id'],
+                        properties: { id: internalRef('jsonValue') },
+                    },
+                ],
+            };
+        }
+        return internalRef(name);
+    };
+    const resolveInput = (reference) => (reference.namespace
+        ? inputs.get(`${reference.namespace}:${reference.type}`)
+        : undefined) ?? inputsByName.get(reference.type);
+    const resolveEnum = (reference) => (reference.namespace
+        ? enums.get(`${reference.namespace}:${reference.type}`)
+        : undefined) ?? enumsByName.get(reference.type);
+    const ensureEnum = (info) => {
+        const name = enumDefinitionName(info);
+        if (!(name in definitions)) {
+            definitions[name] = { type: 'string', enum: [...info.enumType.values] };
+        }
+        return name;
+    };
+    const ensureInput = (info) => {
+        const name = inputDefinitionName(info);
+        if (name in definitions)
+            return name;
+        definitions[name] = {};
+        const properties = {};
+        const required = [];
+        const relations = rootRelations.get(info.input.name);
+        for (const field of info.input.fields) {
+            const alternatives = field.inputTypes.map((reference) => {
+                let value;
+                if (reference.location === 'scalar') {
+                    value = scalarSchema(reference.type);
+                }
+                else if (reference.location === 'inputObjectTypes') {
+                    const input = resolveInput(reference);
+                    value = input
+                        ? internalRef(ensureInput(input))
+                        : internalRef('jsonValue');
+                }
+                else if (reference.location === 'enumTypes') {
+                    const enumType = resolveEnum(reference);
+                    value = enumType
+                        ? internalRef(ensureEnum(enumType))
+                        : { type: 'string' };
+                }
+                else {
+                    value = internalRef('jsonValue');
+                }
+                return reference.isList
+                    ? { type: 'array', items: { anyOf: [value, dynamicString()] } }
+                    : value;
+            });
+            const relationList = relations?.get(field.name);
+            if (relationList !== undefined) {
+                const record = connectionRecord();
+                alternatives.push(record);
+                if (relationList) {
+                    alternatives.push({
+                        type: 'array',
+                        items: { anyOf: [dynamicString(), record] },
+                    });
+                }
+            }
+            alternatives.push(dynamicString());
+            if (field.isNullable)
+                alternatives.push({ type: 'null' });
+            properties[field.name] = {
+                ...(field.comment ? { description: field.comment } : {}),
+                anyOf: alternatives,
+            };
+            if (field.isRequired)
+                required.push(field.name);
+        }
+        definitions[name] = {
+            type: 'object',
+            additionalProperties: false,
+            properties,
+            ...(required.length ? { required } : {}),
+        };
+        return name;
+    };
+    const entityNames = [
+        ...new Set(dmmf.datamodel.models.flatMap(({ name }) => [
+            name,
+            name[0].toLowerCase() + name.slice(1),
+        ])),
+    ];
+    schema.properties.entity = entityNames.length
+        ? {
+            description: 'Prisma model or lowercase-first delegate name.',
+            allOf: [{ $ref: '#/definitions/entityName' }],
+            enum: entityNames,
+        }
+        : {
+            description: 'No Prisma models are available.',
+            not: {},
+        };
+    const modelConditions = [];
+    for (const model of dmmf.datamodel.models) {
+        const aliases = [
+            ...new Set([
+                model.name,
+                model.name[0].toLowerCase() + model.name.slice(1),
+            ]),
+        ];
+        const relationNames = model.fields
+            .filter((field) => field.kind === 'object')
+            .map((field) => field.name);
+        const roots = [
+            inputs.get(`prisma:${model.name}CreateInput`) ??
+                inputsByName.get(`${model.name}CreateInput`),
+            inputs.get(`prisma:${model.name}UncheckedCreateInput`) ??
+                inputsByName.get(`${model.name}UncheckedCreateInput`),
+        ].filter((value) => value !== undefined);
+        const itemSchemas = roots.map((root) => internalRef(ensureInput(root)));
+        const thenSchema = {
+            properties: {
+                connectedFields: relationNames.length
+                    ? { items: { enum: relationNames } }
+                    : { maxItems: 0 },
+            },
+        };
+        if (itemSchemas.length) {
+            thenSchema.allOf = [
+                {
+                    if: { not: { required: ['processor'] } },
+                    then: {
+                        properties: {
+                            items: {
+                                additionalProperties: itemSchemas.length === 1
+                                    ? itemSchemas[0]
+                                    : { anyOf: itemSchemas },
+                            },
+                        },
+                    },
+                },
+            ];
+        }
+        modelConditions.push({
+            if: {
+                required: ['entity'],
+                properties: { entity: { enum: aliases } },
+            },
+            then: thenSchema,
+        });
+    }
+    schema.allOf = [...(schema.allOf ?? []), ...modelConditions];
+    return schema;
+}
+const inputDefinitionName = ({ input, namespace }) => `PrismaInput_${namespace}_${input.name}`;
+const enumDefinitionName = ({ enumType, namespace }) => `PrismaEnum_${namespace}_${enumType.name}`;
+const internalRef = (name) => ({
+    $ref: `#/definitions/${pointer(name)}`,
+});
+const scalarSchema = (type) => {
+    if (type === 'Int')
+        return { type: 'integer' };
+    if (type === 'Float')
+        return { type: 'number' };
+    if (type === 'Decimal') {
+        return {
+            anyOf: [{ type: 'number' }, { type: 'string' }],
+        };
+    }
+    if (type === 'String' || type === 'DateTime')
+        return { type: 'string' };
+    if (type === 'Boolean')
+        return { type: 'boolean' };
+    if (type === 'BigInt') {
+        return {
+            anyOf: [{ type: 'integer' }, { type: 'string', pattern: '^-?[0-9]+$' }],
+        };
+    }
+    if (type === 'Json')
+        return internalRef('jsonValue');
+    if (type === 'Null')
+        return { type: 'null' };
+    if (type === 'Bytes') {
+        return {
+            description: 'Bytes constructors are validated by Prisma at runtime; fixture structure remains permissive.',
+        };
+    }
+    return internalRef('jsonValue');
+};

package/dist/fixture-template.d.ts

@@ -0,0 +1,14 @@
+import { type FixtureDefinition } from './fixture-document';
+export type FixtureProcessor = {
+    preProcess?: (name: string, data: Record<string, unknown>) => unknown | Promise<unknown>;
+};
+export type ProcessorConstructor = new () => FixtureProcessor;
+type FixtureRandomizer = {
+    next(): number;
+    seed(value: number | number[]): void;
+};
+export declare function renderFixtureTemplates(fixture: FixtureDefinition, randomizer: FixtureRandomizer, refDate?: string): Promise<Record<string, unknown>>;
+export declare function createFixtureRandomizer(seed?: number): Promise<FixtureRandomizer>;
+export declare function loadFixtureProcessor(processorPath: string): Promise<ProcessorConstructor>;
+export declare function runFixtureProcessor(constructor: ProcessorConstructor | undefined, fixture: FixtureDefinition, data: Record<string, unknown>): Promise<Record<string, unknown>>;
+export {};

package/dist/fixture-template.js

@@ -0,0 +1,239 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderFixtureTemplates = renderFixtureTemplates;
+exports.createFixtureRandomizer = createFixtureRandomizer;
+exports.loadFixtureProcessor = loadFixtureProcessor;
+exports.runFixtureProcessor = runFixtureProcessor;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+const ejs_1 = __importDefault(require("ejs"));
+const fixture_error_1 = require("./fixture-error");
+const fixture_document_1 = require("./fixture-document");
+const requireProcessor = (0, node_module_1.createRequire)(__filename);
+const PROCESSOR_EXTENSIONS = ['.js', '.cjs', '.mjs', '.ts', '.cts', '.mts'];
+async function renderFixtureTemplates(fixture, randomizer, refDate) {
+    const fakerModule = await import('@faker-js/faker');
+    let locale = fakerModule.en;
+    if (fixture.locale) {
+        if (!Object.hasOwn(fakerModule.allLocales, fixture.locale)) {
+            throw (0, fixture_error_1.createFixtureError)('FIXTURE_TEMPLATE_FAILED', 'Unknown Faker locale', (0, fixture_document_1.fixtureErrorContext)(fixture, 'rendering templates'));
+        }
+        locale =
+            fakerModule.allLocales[fixture.locale];
+    }
+    const generator = new fakerModule.Faker({
+        locale: locale === fakerModule.en ? [locale] : [locale, fakerModule.en],
+        randomizer,
+    });
+    if (refDate !== undefined)
+        generator.setDefaultRefDate(refDate);
+    const data = renderValue(fixture.data, fixture, generator, '');
+    if (!(0, fixture_document_1.isFixtureRecord)(data)) {
+        throw (0, fixture_error_1.createFixtureError)('FIXTURE_TEMPLATE_FAILED', 'Fixture template produced invalid data', (0, fixture_document_1.fixtureErrorContext)(fixture, 'rendering templates'));
+    }
+    try {
+        (0, fixture_document_1.assertSafeFixtureValue)(data);
+    }
+    catch (error) {
+        throw (0, fixture_error_1.wrapFixtureError)(error, 'FIXTURE_TEMPLATE_FAILED', 'Fixture template produced invalid data', (0, fixture_document_1.fixtureErrorContext)(fixture, 'rendering templates'));
+    }
+    return data;
+}
+async function createFixtureRandomizer(seed) {
+    const { generateMersenne53Randomizer } = await import('@faker-js/faker');
+    return generateMersenne53Randomizer(seed);
+}
+function renderValue(value, fixture, faker, path) {
+    if (Array.isArray(value)) {
+        return value.map((item, index) => renderValue(item, fixture, faker, (0, fixture_error_1.appendFixturePath)(path, index)));
+    }
+    if ((0, fixture_document_1.isFixtureRecord)(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+            key,
+            renderValue(item, fixture, faker, (0, fixture_error_1.appendFixturePath)(path, key)),
+        ]));
+    }
+    if (typeof value !== 'string')
+        return value;
+    try {
+        const template = value.includes('<%') ? ejs_1.default.render(value, fixture) : value;
+        const providerPattern = /\{\{([\s\S]*?)\}\}/g;
+        const providers = [...template.matchAll(providerPattern)];
+        const singleProvider = providers.length === 1 && providers[0][0].length === template.length
+            ? providers[0]
+            : undefined;
+        const generated = singleProvider
+            ? fakeValue(singleProvider[1], faker)
+            : template.replace(providerPattern, (_token, provider) => String(fakeValue(provider, faker)));
+        if (typeof generated !== 'string') {
+            (0, fixture_document_1.assertSafeFixtureValue)(generated);
+            return generated;
+        }
+        return generated.replace(/<\{(.*?)\}>/g, (_token, key) => String(parameterValue(fixture.parameters, key) ?? ''));
+    }
+    catch (error) {
+        throw (0, fixture_error_1.wrapFixtureError)(error, 'FIXTURE_TEMPLATE_FAILED', 'Fixture template failed', (0, fixture_document_1.fixtureErrorContext)(fixture, 'rendering templates', path));
+    }
+}
+function fakeValue(expression, faker) {
+    const match = expression.trim().match(/^(\w+)\.(\w+)(?:\(([\s\S]*)\))?$/);
+    if (!match)
+        throw new Error('Invalid Faker provider');
+    const [group, method] = modernProvider(match[1], match[2]);
+    const argument = match[3];
+    if (fixture_document_1.DANGEROUS_KEYS.has(group) || fixture_document_1.DANGEROUS_KEYS.has(method)) {
+        throw new Error('Invalid Faker provider');
+    }
+    const providerGroup = faker[group];
+    if (providerGroup === null || typeof providerGroup !== 'object') {
+        throw new Error('Unknown Faker provider');
+    }
+    const provider = providerGroup[method];
+    if (typeof provider !== 'function')
+        throw new Error('Unknown Faker provider');
+    if (argument === undefined || !argument.trim())
+        return provider.call(providerGroup);
+    let parameter = argument;
+    try {
+        parameter = JSON.parse(argument);
+    }
+    catch {
+        // The upstream syntax accepts a plain string as the single provider argument.
+    }
+    if (group === 'date' && method === 'past' && typeof parameter === 'number') {
+        parameter = { years: parameter };
+    }
+    return provider.call(providerGroup, parameter);
+}
+function modernProvider(group, method) {
+    if (group === 'name')
+        return ['person', method === 'title' ? 'jobTitle' : method];
+    if (group === 'address')
+        return ['location', method];
+    if (group === 'internet' && method === 'userName')
+        return [group, 'username'];
+    if (group === 'random' && method === 'number')
+        return ['number', 'int'];
+    if (group === 'random' && method === 'alphaNumeric')
+        return ['string', 'alphanumeric'];
+    if (group === 'random' && method === 'arrayElement')
+        return ['helpers', 'arrayElement'];
+    if (group === 'random' && method === 'word')
+        return ['word', 'sample'];
+    if (group === 'datatype' && method === 'number')
+        return ['number', 'int'];
+    if (group === 'datatype' && method === 'float')
+        return ['number', 'float'];
+    if (group === 'datatype' && method === 'datetime')
+        return ['date', 'anytime'];
+    if (group === 'datatype' && method === 'string')
+        return ['string', 'sample'];
+    return [group, method];
+}
+function parameterValue(parameters, key) {
+    const parts = key.split('.');
+    if (parts.some((part) => fixture_document_1.DANGEROUS_KEYS.has(part))) {
+        throw (0, fixture_error_1.createFixtureError)('FIXTURE_TEMPLATE_FAILED', 'Unknown fixture parameter', { stage: 'rendering templates' });
+    }
+    let value = parameters;
+    let found = true;
+    for (const part of parts) {
+        if (!(0, fixture_document_1.isFixtureRecord)(value) || !Object.hasOwn(value, part)) {
+            found = false;
+            break;
+        }
+        value = value[part];
+    }
+    if (found && value !== undefined)
+        return value;
+    if (parts.length === 3 && parts[0] === 'process' && parts[1] === 'env') {
+        const variable = parts[2];
+        if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(variable)) {
+            const environmentValue = process.env[variable];
+            if (environmentValue !== undefined)
+                return environmentValue;
+        }
+    }
+    throw (0, fixture_error_1.createFixtureError)('FIXTURE_TEMPLATE_FAILED', 'Unknown fixture parameter', { stage: 'rendering templates' });
+}
+async function loadFixtureProcessor(processorPath) {
+    const resolvedPath = resolveProcessorPath(processorPath);
+    let loaded;
+    try {
+        loaded = requireProcessor(resolvedPath);
+    }
+    catch (error) {
+        if (!requiresNativeImport(error))
+            throw error;
+        loaded = await import((0, node_url_1.pathToFileURL)(resolvedPath).href);
+    }
+    let constructor = loaded;
+    for (let depth = 0; depth < 2 && (0, fixture_document_1.isFixtureRecord)(constructor); depth += 1) {
+        if (!Object.hasOwn(constructor, 'default'))
+            break;
+        constructor = constructor.default;
+    }
+    if (typeof constructor !== 'function') {
+        throw new Error('Fixture processor must export a default class');
+    }
+    return constructor;
+}
+function requiresNativeImport(error) {
+    if (error === null || typeof error !== 'object' || !('code' in error)) {
+        return false;
+    }
+    const code = error.code;
+    return code === 'ERR_REQUIRE_ESM' || code === 'ERR_REQUIRE_ASYNC_MODULE';
+}
+function resolveProcessorPath(processorPath) {
+    if (node_path_1.default.extname(processorPath))
+        return processorPath;
+    try {
+        return requireProcessor.resolve(processorPath);
+    }
+    catch {
+        for (const extension of PROCESSOR_EXTENSIONS) {
+            const candidate = `${processorPath}${extension}`;
+            try {
+                if (node_fs_1.default.statSync(candidate).isFile())
+                    return candidate;
+            }
+            catch {
+                // Continue through the bounded extension list.
+            }
+        }
+    }
+    throw new Error('Fixture processor module not found');
+}
+async function runFixtureProcessor(constructor, fixture, data) {
+    let result = data;
+    try {
+        if (constructor) {
+            const processor = new constructor();
+            if (processor.preProcess !== undefined) {
+                if (typeof processor.preProcess !== 'function') {
+                    throw new Error('Invalid fixture processor hook');
+                }
+                result = await processor.preProcess(fixture.name, data);
+            }
+        }
+    }
+    catch (error) {
+        throw (0, fixture_error_1.wrapFixtureError)(error, 'FIXTURE_PROCESSOR_FAILED', 'Fixture processor failed', (0, fixture_document_1.fixtureErrorContext)(fixture, 'processing fixture'));
+    }
+    if (!(0, fixture_document_1.isFixtureRecord)(result)) {
+        throw (0, fixture_error_1.createFixtureError)('FIXTURE_PROCESSOR_FAILED', 'Fixture processor returned invalid data', (0, fixture_document_1.fixtureErrorContext)(fixture, 'processing fixture'));
+    }
+    try {
+        (0, fixture_document_1.assertSafeFixtureValue)(result);
+    }
+    catch (error) {
+        throw (0, fixture_error_1.wrapFixtureError)(error, 'FIXTURE_PROCESSOR_FAILED', 'Fixture processor returned invalid data', (0, fixture_document_1.fixtureErrorContext)(fixture, 'processing fixture'));
+    }
+    return result;
+}

package/dist/generator.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/generator.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const generator_helper_1 = require("@prisma/generator-helper");
+const fixture_schema_1 = require("./fixture-schema");
+(0, generator_helper_1.generatorHandler)({
+    onManifest() {
+        return {
+            prettyName: 'Prisma Fixtures',
+            defaultOutput: './generated/fixtures',
+        };
+    },
+    async onGenerate(options) {
+        const output = options.generator.output?.value;
+        if (!output)
+            throw new Error('Prisma Fixtures generator requires an output path');
+        node_fs_1.default.mkdirSync(output, { recursive: true });
+        node_fs_1.default.writeFileSync(node_path_1.default.join(output, 'schema.json'), `${JSON.stringify((0, fixture_schema_1.buildFixtureSchema)(options.dmmf), null, 2)}\n`);
+    },
+});

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { type FixtureDefinition, readFixtureDocuments } from './fixture-document';
+import { type FixtureCleanupOptions } from './cleanup-options';
+import { type FixtureLoadOptions, type FixtureResetOptions } from './load-options';
+export type { FixtureDefinition } from './fixture-document';
+export { FixtureError } from './fixture-error';
+export type { FixtureErrorCode, FixtureErrorContext } from './fixture-error';
+export type { FixtureProcessor } from './fixture-template';
+export type { FixtureCleanupOptions, FixturePreservedTable, } from './cleanup-options';
+export type { FixtureLoadOptions, FixtureResetOptions } from './load-options';
+export declare const readFixtureDefinitions: typeof readFixtureDocuments;
+export declare class PrismaFixtures {
+    load(client: object): Promise<Record<string, Record<string, unknown>>>;
+}
+export type FixtureWriter = (fixture: FixtureDefinition, data: Record<string, unknown>) => Promise<unknown>;
+export declare function loadFixtures(client: object, definitions: FixtureDefinition[], write?: FixtureWriter): Promise<Record<string, Record<string, unknown>>>;
+export declare function loadFixtures(client: object, definitions: FixtureDefinition[], options?: FixtureLoadOptions, write?: FixtureWriter): Promise<Record<string, Record<string, unknown>>>;
+export declare function cleanFixtures(client: object, options?: FixtureCleanupOptions): Promise<void>;
+export declare function resetFixtures(client: object, definitions: FixtureDefinition[], write?: FixtureWriter): Promise<Record<string, Record<string, unknown>>>;
+export declare function resetFixtures(client: object, definitions: FixtureDefinition[], options?: FixtureResetOptions, write?: FixtureWriter): Promise<Record<string, Record<string, unknown>>>;