Code Generation Tools

Introduction

A powerful code generation package that creates GraphQL schemas, resolvers, and admin interfaces from Prisma schema definitions. Supports multiple GraphQL architectures including Nexus, SDL-first, and GraphQL Modules.

Installation

Main Classes

Generator

The main class that orchestrates code generation based on the specified generator type.

typescript

import { Generator } from "@paljs/generator";
 
const generator = new Generator(
  {
    name: "nexus", // 'nexus' | 'sdl' | 'graphql-modules'
    schemaPath: "./prisma/schema.prisma",
  },
  {
    output: "./src/graphql",
    excludeFields: ["password"],
    // ... other options
  }
);
 
await generator.run();

Constructor Parameters:

generator - Configuration object with generator name and schema path
options - Optional generator options for customization

Methods:

run() - Execute the code generation process

GenerateNexus

Generates Nexus GraphQL schema with type-safe resolvers and input types.

typescript

import { GenerateNexus } from "@paljs/generator";
 
const nexusGenerator = new GenerateNexus("./prisma/schema.prisma", {
  output: "./src/graphql",
  prismaName: "prisma",
  excludeFields: ["password", "hash"],
});
 
await nexusGenerator.run();

Generated Files:

types.ts - Nexus object type definitions
inputs.ts - Input type definitions
queries.ts - Query field definitions
mutations.ts - Mutation field definitions
index.ts - Combined exports

Key Methods:

run() - Generate all Nexus files
createTypes() - Generate object types
createInputs() - Generate input types
createQueries() - Generate query fields
createMutations() - Generate mutation fields

GenerateSdl

Generates Schema Definition Language (SDL) files with resolver functions.

typescript

import { GenerateSdl } from "@paljs/generator";
 
const sdlGenerator = new GenerateSdl("./prisma/schema.prisma", {
  output: "./src/graphql",
  javaScript: false,
});
 
await sdlGenerator.run();

Generated Files:

typeDefs.ts - GraphQL type definitions
resolvers.ts - Resolver implementations
index.ts - Combined exports

Key Methods:

run() - Generate all SDL files
createTypes() - Generate type definitions
createResolvers() - Generate resolver functions
createMaster() - Create index files

GenerateModules

Generates GraphQL Modules architecture with modular schema organization.

typescript

import { GenerateModules } from "@paljs/generator";
 
const modulesGenerator = new GenerateModules("./prisma/schema.prisma", {
  output: "./src/graphql",
});
 
await modulesGenerator.run();

Generated Files:

modules/ - Individual model modules
inputs/ - Shared input types
app.ts - Application module configuration

Key Methods:

run() - Generate all module files
createModules() - Generate individual modules
createInputs() - Generate input types
createApp() - Generate application module

UIGenerator

Generates admin UI components and pages for Prisma models.

typescript

import { UIGenerator } from "@paljs/generator";
 
const uiGenerator = new UIGenerator("./prisma/schema.prisma");
 
await uiGenerator.generateAdminPages({
  models: ["User", "Post", "Category"],
  output: "./src/admin/pages",
});

Key Methods:

generateAdminPages() - Generate admin interface pages
mergeSchemas() - Merge multiple schemas for multi-database support

Usage Examples

Basic Nexus Generation

typescript

import { Generator } from "@paljs/generator";
 
const generator = new Generator(
  { name: "nexus", schemaPath: "./prisma/schema.prisma" },
  {
    output: "./src/graphql",
    prismaName: "prisma",
    excludeFields: ["password", "hash"],
    excludeModels: [{ name: "Log", queries: true, mutations: true }],
  }
);
 
await generator.run();

SDL Generation with Custom Configuration

typescript

import { GenerateSdl } from "@paljs/generator";
 
const generator = new GenerateSdl("./prisma/schema.prisma", {
  output: "./src/graphql",
  javaScript: false,
  excludeQueriesAndMutations: ["deleteMany", "updateMany"],
  excludeFieldsByModel: {
    User: ["password", "hash"],
    Post: ["internalNotes"],
  },
});
 
await generator.run();

GraphQL Modules Generation

typescript

import { GenerateModules } from "@paljs/generator";
 
const generator = new GenerateModules("./prisma/schema.prisma", {
  output: "./src/graphql",
  excludeFields: ["password"],
  excludeModels: [{ name: "Session", queries: true, mutations: true }],
});
 
await generator.run();

Admin UI Generation

typescript

import { UIGenerator } from "@paljs/generator";
 
const uiGenerator = new UIGenerator("./prisma/schema.prisma");
 
// Generate admin pages for specific models
await uiGenerator.generateAdminPages({
  models: ["User", "Post", "Category", "Tag"],
  output: "./src/admin/pages",
  pageContent: `
import { PrismaTable } from '@paljs/admin';
import { useQuery } from '@apollo/client';
import { GET_{{MODEL}}_QUERY } from '../queries/{{model}}';
 
export default function {{Model}}Page() {
  const { data, loading, error } = useQuery(GET_{{MODEL}}_QUERY);
  
  if (loading) return <div>Loading...</div>;
  if (error) return <div>Error: {error.message}</div>;
  
  return (
    <PrismaTable
      model="{{Model}}"
      data={data?.{{models}} || []}
      columns={{{model}}Columns}
    />
  );
}
  `,
});

Configuration Options

Generator Options

typescript

interface GeneratorOptions {
  // Output directory for generated files
  output: string;
 
  // Prisma client instance name
  prismaName?: string;
 
  // Generate JavaScript instead of TypeScript
  javaScript?: boolean;
 
  // Return generated code as text instead of writing files
  backAsText?: boolean;
 
  // Models to include in generation
  models?: string[];
 
  // Fields to exclude globally
  excludeFields?: string[];
 
  // Models to exclude with specific operations
  excludeModels?: Array<{
    name: string;
    queries?: boolean;
    mutations?: boolean;
  }>;
 
  // Disable all queries or mutations
  disableQueries?: boolean;
  disableMutations?: boolean;
 
  // Fields to exclude per model
  excludeFieldsByModel?: Record<string, string[]>;
 
  // Queries/mutations to exclude per model
  excludeQueriesAndMutationsByModel?: Record<string, string[]>;
 
  // Queries/mutations to exclude globally
  excludeQueriesAndMutations?: string[];
 
  // Input fields to exclude
  excludeInputFields?: string[];
 
  // Custom input filter function
  filterInputs?: (input: any) => any[];
 
  // Disable field update operations input
  doNotUseFieldUpdateOperationsInput?: boolean;
}

Admin Options

typescript

interface AdminOptions {
  // Models to include in admin interface
  models: string[];
 
  // Output directory for admin pages
  output: string;
 
  // Custom page template content
  pageContent?: string;
 
  // Exclude specific fields from admin
  excludeFields?: Record<string, string[]>;
 
  // Custom field configurations
  fieldConfigs?: Record<string, FieldConfig[]>;
}

Generated Code Examples

Nexus Object Types

typescript

// Generated types.ts
import { objectType } from "nexus";
 
export const User = objectType({
  name: "User",
  definition(t) {
    t.nonNull.int("id");
    t.nonNull.string("email");
    t.string("name");
    t.nonNull.dateTime("createdAt");
    t.nonNull.dateTime("updatedAt");
    t.list.field("posts", {
      type: "Post",
      resolve: (parent, _, { prisma, select }) =>
        prisma.user.findUnique({ where: { id: parent.id } }).posts(select),
    });
  },
});

SDL Type Definitions

typescript

// Generated typeDefs.ts
export const typeDefs = gql`
  type User {
    id: Int!
    email: String!
    name: String
    createdAt: DateTime!
    updatedAt: DateTime!
    posts: [Post!]!
  }
 
  type Query {
    findUniqueUser(where: UserWhereUniqueInput!): User
    findManyUser(
      where: UserWhereInput
      orderBy: [UserOrderByWithRelationInput!]
      cursor: UserWhereUniqueInput
      take: Int
      skip: Int
    ): [User!]!
  }
 
  type Mutation {
    createOneUser(data: UserCreateInput!): User!
    updateOneUser(where: UserWhereUniqueInput!, data: UserUpdateInput!): User
    deleteOneUser(where: UserWhereUniqueInput!): User
  }
`;

GraphQL Modules

typescript

// Generated modules/User/index.ts
import { createModule } from "graphql-modules";
import { typeDefs } from "./typeDefs";
import { resolvers } from "./resolvers";
 
export const UserModule = createModule({
  id: "user",
  typeDefs,
  resolvers,
});

Advanced Features

Multi-Schema Support

typescript

import { UIGenerator } from "@paljs/generator";
 
const uiGenerator = new UIGenerator();
 
// Merge multiple schemas
const mergedSchema = await uiGenerator.mergeSchemas([
  "./schemas/user.prisma",
  "./schemas/blog.prisma",
  "./schemas/commerce.prisma",
]);
 
// Generate from merged schema
const generator = new Generator(
  { name: "nexus", schema: mergedSchema },
  { output: "./src/graphql" }
);

Custom Filters

typescript

const generator = new GenerateNexus("./prisma/schema.prisma", {
  output: "./src/graphql",
  filterInputs: (input) => {
    // Custom logic to filter input fields
    return input.fields.filter(
      (field) => !field.name.startsWith("internal") && field.name !== "password"
    );
  },
});

Conditional Generation

typescript

const isProduction = process.env.NODE_ENV === "production";
 
const generator = new Generator(
  { name: "nexus", schemaPath: "./prisma/schema.prisma" },
  {
    output: "./src/graphql",
    excludeModels: isProduction
      ? [{ name: "DebugLog", queries: true, mutations: true }]
      : [],
    excludeFields: isProduction ? ["debugInfo"] : [],
  }
);

Features

Multiple GraphQL Architectures: Support for Nexus, SDL-first, and GraphQL Modules
Type Safety: Full TypeScript support with proper type inference
Flexible Configuration: Extensive options for customizing generation
Admin Interface: Automatic admin page generation
Multi-Schema Support: Handle multiple Prisma schemas
Field Filtering: Exclude sensitive or unnecessary fields
Custom Templates: Support for custom code templates
Incremental Generation: Generate only what you need
Production Ready: Optimized for production environments

Command Palette