prisma-factory/dist/generator.mjs

Generates factories for your prisma models

import "./chunk-U4G2LS47.mjs";

// src/cli/generator.ts
import { generatorHandler } from "@prisma/generator-helper";

// src/cli/factory-generator.ts
import { parseEnvValue } from "@prisma/internals";
import { resolve } from "path";
import { Project } from "ts-morph";

// src/generator/factories.ts
function addFactoryFunctions(sourceFile, dmmf, options) {
  return dmmf.datamodel.models.map((m) => addModelFactoryFunction(sourceFile, m, options));
}
function addModelFactoryFunction(sourceFile, model, options) {
  const newFunction = sourceFile.addFunction({
    name: `create${model.name}Factory`
  });
  newFunction.insertParameters(0, [
    {
      name: "requiredAttrs",
      type: `ObjectWithMaybeCallbacks<Prisma.${model.name}CreateInput>`,
      hasQuestionToken: true
    }
  ]);
  newFunction.insertParameters(1, [
    {
      name: "options",
      type: `CreateFactoryOptions`,
      hasQuestionToken: true
    }
  ]);
  newFunction.insertParameters(2, [
    {
      name: "hooks",
      type: `CreateFactoryHooks<Prisma.${model.name}CreateInput, ${model.name}>`,
      hasQuestionToken: true
    }
  ]);
  newFunction.setBodyText(`return createFactory<Prisma.${model.name}CreateInput, ${model.name}>('${model.name}', requiredAttrs, { ...options, client: '${options.client}' }, hooks); `);
  newFunction.setReturnType(`CreateFactoryReturn<Prisma.${model.name}CreateInput, ${model.name}>`);
  newFunction.setIsExported(true);
}
function addImports(sourceFile, dmmf, options) {
  const modelNames = dmmf.datamodel.models.map((m) => m.name);
  const prismaImports = ["Prisma"].concat(modelNames);
  sourceFile.addImportDeclarations([
    {
      moduleSpecifier: "prisma-factory",
      namedImports: ["CreateFactoryOptions", "CreateFactoryHooks", "CreateFactoryReturn"],
      isTypeOnly: true
    },
    {
      moduleSpecifier: "prisma-factory",
      namedImports: ["ObjectWithMaybeCallbacks"],
      isTypeOnly: true
    },
    {
      moduleSpecifier: "prisma-factory",
      namedImports: ["createFactory"]
    },
    {
      moduleSpecifier: options.client,
      namedImports: prismaImports
    }
  ]);
}
function generateFactories(sourceFile, dmmf, options) {
  var _a, _b;
  addImports(sourceFile, dmmf, { client: (_a = options.client) != null ? _a : "@prisma/client" });
  addFactoryFunctions(sourceFile, dmmf, { client: (_b = options.client) != null ? _b : "@prisma/client" });
}

// src/cli/factory-generator.ts
async function generate(options) {
  const prismaClientOutput = options.otherGenerators.find((gen) => gen.provider.value === "prisma-client-js").output.value;
  const outputDir = parseEnvValue(options.generator.output);
  try {
    const project = new Project({ compilerOptions: { outDir: outputDir, declaration: true } });
    const factoryFile = project.createSourceFile("index.ts", void 0, { overwrite: true });
    generateFactories(factoryFile, options.dmmf, {
      client: prismaClientOutput === "@prisma/client" ? "@prisma/client" : resolve(outputDir, prismaClientOutput)
    });
    await project.emit();
  } catch (e) {
    console.error("Error: unable to write files for Prisma Factory");
    throw e;
  }
}

// src/cli/generator.ts
generatorHandler({
  onManifest: () => ({
    defaultOutput: "node_modules/prisma-factory/generated",
    prettyName: "Prisma Factories",
    requiresGenerators: ["prisma-client-js"]
  }),
  onGenerate: generate
});