@nestledjs/api 0.0.1

package/src/generate-crud/files/data-access/src/lib/dto/index.ts__tmpl__

@@ -0,0 +1,224 @@
+<%# EJS template for generating DTOs %>
+<%
+let gqlImports = new Set(['Field', 'InputType']);
+let usesGraphQLJSON = false;
+let usesInt = false;
+let usesFloat = false;
+let usesID = false;
+let enumNames = new Set();
+
+// First pass to determine necessary imports and enums
+for (const model of models) {
+  for (const field of model.fields) {
+    if (field.type === 'Int') usesInt = true;
+    if (field.type === 'Float' || field.type === 'Decimal') usesFloat = true;
+    if (field.type === 'Json') usesGraphQLJSON = true;
+
+    if (field.type === 'ID') { // Explicit ID field
+        usesID = true;
+    } else if (field.kind === 'object') {
+        // Check if a corresponding scalar ID field (e.g., 'userId') exists for this object field (e.g., 'user')
+        const correspondingIdFieldName = `${field.name}Id`;
+        const hasCorrespondingIdField = model.fields.some(f => f.name === correspondingIdFieldName && f.kind !== 'object');
+        if (!hasCorrespondingIdField) {
+            // If no pre-existing '...Id' scalar, we'll generate one, so 'ID' import is needed.
+            usesID = true;
+        }
+    } else if (field.kind === 'enum') {
+        enumNames.add(field.type);
+    }
+  }
+}
+
+if (usesInt) gqlImports.add('Int');
+if (usesFloat) gqlImports.add('Float');
+if (usesID) gqlImports.add('ID');
+%>
+import { <%= Array.from(gqlImports).join(', ') %> } from '@nestjs/graphql'
+
+<% if (enumNames.size > 0) { %>import { <%= Array.from(enumNames).join(', ') %> } from '<%= npmScope %>/api/core/models'
+<% } %><% if (usesGraphQLJSON) { %>import { GraphQLJSON } from 'graphql-type-json'<% } %>
+import { CorePagingInput } from '<%= npmScope %>/api/core/data-access'
+
+<% for (const model of models) { %>
+@InputType()
+export class Create<%= model.modelName %>Input {
+<% for (const field of model.fields) { %>
+  <%
+    let shouldSkipField = false;
+    let baseGqlType;
+    let tsType;
+    let effectiveFieldName = field.name;
+
+    if (field.kind === 'object') {
+        const correspondingIdFieldName = `${field.name}Id`;
+        const hasCorrespondingIdField = model.fields.some(f => f.name === correspondingIdFieldName && f.kind !== 'object');
+        if (hasCorrespondingIdField) {
+            shouldSkipField = true; // Skip this object field; its ID is handled by the existing scalar field.
+        } else {
+            // No corresponding '...Id' scalar found, so generate an ID field for this relation.
+            baseGqlType = 'ID';
+            tsType = 'string';
+            effectiveFieldName = correspondingIdFieldName;
+        }
+    } else {
+        // Handle non-object (scalar, enum, or explicit ID) fields
+        effectiveFieldName = field.name;
+        if (field.type === 'String') { baseGqlType = 'String'; tsType = 'string'; }
+        else if (field.type === 'Int') { baseGqlType = 'Int'; tsType = 'number'; }
+        else if (field.type === 'Float') { baseGqlType = 'Float'; tsType = 'number'; }
+        else if (field.type === 'Decimal') { baseGqlType = 'Float'; tsType = 'number'; }
+        else if (field.type === 'Boolean') { baseGqlType = 'Boolean'; tsType = 'boolean'; }
+        else if (field.type === 'DateTime') { baseGqlType = 'Date'; tsType = 'Date'; }
+        else if (field.type === 'Json') { baseGqlType = 'GraphQLJSON'; tsType = 'typeof GraphQLJSON'; }
+        else if (field.type === 'ID') { baseGqlType = 'ID'; tsType = 'string'; }
+        else if (field.kind === 'enum') {
+            baseGqlType = field.type;
+            tsType = field.type;
+        } else { // Fallback, should ideally not be reached if all model types are known
+            baseGqlType = 'String'; tsType = 'string';
+        }
+    }
+
+    let fieldDecoratorTypeArg = '';
+    let finalTsType = tsType;
+
+    if (!shouldSkipField) {
+        if (field.isList) { // Use original field's isList property
+            fieldDecoratorTypeArg = `() => [${baseGqlType}]`; // baseGqlType is 'ID' if transformed from object list
+            finalTsType = tsType + '[]'; // tsType is 'string' for ID, so 'string[]'
+        } else {
+            // For non-list fields (scalars or single objects transformed to ID)
+            if (baseGqlType !== 'String' && baseGqlType !== 'Boolean') {
+                fieldDecoratorTypeArg = `() => ${baseGqlType}`;
+            }
+            // finalTsType is already 'tsType', which is correct
+        }
+    }
+  %>
+  <% if (!shouldSkipField) { %>
+  @Field(<% if (fieldDecoratorTypeArg) { %><%- fieldDecoratorTypeArg %>, <% } %>{ nullable: true })
+  <%= effectiveFieldName %>?: <%= finalTsType %>
+  <% } %>
+<% } %>
+}
+
+@InputType()
+export class Update<%= model.modelName %>Input {
+<% for (const field of model.fields) { %>
+  <%
+    let shouldSkipField = false;
+    let baseGqlType;
+    let tsType;
+    let effectiveFieldName = field.name;
+
+    if (field.kind === 'object') {
+        const correspondingIdFieldName = `${field.name}Id`;
+        const hasCorrespondingIdField = model.fields.some(f => f.name === correspondingIdFieldName && f.kind !== 'object');
+        if (hasCorrespondingIdField) {
+            shouldSkipField = true;
+        } else {
+            baseGqlType = 'ID';
+            tsType = 'string';
+            effectiveFieldName = correspondingIdFieldName;
+        }
+    } else {
+        effectiveFieldName = field.name;
+        if (field.type === 'String') { baseGqlType = 'String'; tsType = 'string'; }
+        else if (field.type === 'Int') { baseGqlType = 'Int'; tsType = 'number'; }
+        else if (field.type === 'Float') { baseGqlType = 'Float'; tsType = 'number'; }
+        else if (field.type === 'Decimal') { baseGqlType = 'Float'; tsType = 'number'; }
+        else if (field.type === 'Boolean') { baseGqlType = 'Boolean'; tsType = 'boolean'; }
+        else if (field.type === 'DateTime') { baseGqlType = 'Date'; tsType = 'Date'; }
+        else if (field.type === 'Json') { baseGqlType = 'GraphQLJSON'; tsType = 'typeof GraphQLJSON'; }
+        else if (field.type === 'ID') { baseGqlType = 'ID'; tsType = 'string'; }
+        else if (field.kind === 'enum') {
+            baseGqlType = field.type;
+            tsType = field.type;
+        } else {
+            baseGqlType = 'String'; tsType = 'string';
+        }
+    }
+
+    let fieldDecoratorTypeArg = '';
+    let finalTsType = tsType;
+
+    if (!shouldSkipField) {
+        if (field.isList) {
+            fieldDecoratorTypeArg = `() => [${baseGqlType}]`;
+            finalTsType = tsType + '[]';
+        } else {
+            if (baseGqlType !== 'String' && baseGqlType !== 'Boolean') {
+                fieldDecoratorTypeArg = `() => ${baseGqlType}`;
+            }
+        }
+    }
+  %>
+  <% if (!shouldSkipField) { %>
+  @Field(<% if (fieldDecoratorTypeArg) { %><%- fieldDecoratorTypeArg %>, <% } %>{ nullable: true })
+  <%= effectiveFieldName %>?: <%= finalTsType %>
+  <% } %>
+<% } %>
+}
+
+@InputType()
+export class List<%= model.modelName %>Input extends CorePagingInput {
+<% for (const field of model.fields) { %>
+  <%
+    let shouldSkipField = false;
+    let baseGqlType;
+    let tsType;
+    let effectiveFieldName = field.name;
+
+    if (field.kind === 'object') {
+        const correspondingIdFieldName = `${field.name}Id`;
+        const hasCorrespondingIdField = model.fields.some(f => f.name === correspondingIdFieldName && f.kind !== 'object');
+        if (hasCorrespondingIdField) {
+            shouldSkipField = true;
+        } else {
+            // For ListInput, if no direct ...Id field, we create one for filtering by relation ID
+            baseGqlType = 'ID';
+            tsType = 'string';
+            effectiveFieldName = correspondingIdFieldName;
+        }
+    } else {
+        // Handle non-object fields for filtering
+        effectiveFieldName = field.name;
+        if (field.type === 'String') { baseGqlType = 'String'; tsType = 'string'; }
+        else if (field.type === 'Int') { baseGqlType = 'Int'; tsType = 'number'; }
+        else if (field.type === 'Float') { baseGqlType = 'Float'; tsType = 'number'; }
+        else if (field.type === 'Decimal') { baseGqlType = 'Float'; tsType = 'number'; }
+        else if (field.type === 'Boolean') { baseGqlType = 'Boolean'; tsType = 'boolean'; }
+        else if (field.type === 'DateTime') { baseGqlType = 'Date'; tsType = 'Date'; }
+        else if (field.type === 'Json') { baseGqlType = 'GraphQLJSON'; tsType = 'typeof GraphQLJSON'; }
+        else if (field.type === 'ID') { baseGqlType = 'ID'; tsType = 'string'; }
+        else if (field.kind === 'enum') {
+            baseGqlType = field.type;
+            tsType = field.type;
+        } else {
+            baseGqlType = 'String'; tsType = 'string';
+        }
+    }
+
+    let fieldDecoratorTypeArg = '';
+    let finalTsType = tsType;
+
+    if (!shouldSkipField) {
+        if (field.isList) {
+            fieldDecoratorTypeArg = `() => [${baseGqlType}]`;
+            finalTsType = tsType + '[]';
+        } else {
+            if (baseGqlType !== 'String' && baseGqlType !== 'Boolean') {
+                fieldDecoratorTypeArg = `() => ${baseGqlType}`;
+            }
+        }
+    }
+  %>
+  <% if (!shouldSkipField) { %>
+  @Field(<% if (fieldDecoratorTypeArg) { %><%- fieldDecoratorTypeArg %>, <% } %>{ nullable: true })
+  <%= effectiveFieldName %>?: <%= finalTsType %>
+  <% } %>
+<% } %>
+}
+
+<% } %>

package/src/generate-crud/generator.spec.ts

@@ -0,0 +1,84 @@
+// generators/api/src/generate-crud/generator.spec.ts
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing'
+import { GenerateCrudGeneratorDependencies, generateCrudLogic } from './generator'
+import { Tree } from '@nx/devkit'
+
+// The mocked DMMF object
+const dmmf = {
+  datamodel: {
+    models: [
+      {
+        name: 'User',
+        fields: [
+          { name: 'id', type: 'Int', isId: true },
+          { name: 'name', type: 'String', isId: false },
+        ],
+      },
+    ],
+  },
+}
+
+describe('generate-crud generator', () => {
+  let tree: Tree
+  let mockDependencies: GenerateCrudGeneratorDependencies
+
+  beforeEach(() => {
+    tree = createTreeWithEmptyWorkspace()
+    tree.write('prisma/schema.prisma', 'model User {}')
+
+    mockDependencies = {
+      formatFiles: vi.fn(),
+      generateFiles: vi.fn(),
+      installPackagesTask: vi.fn(),
+      joinPathFragments: vi.fn((...args: string[]) => args.join('/')),
+      names: vi.fn((name: string) => ({
+        name,
+        className: name.charAt(0).toUpperCase() + name.slice(1),
+        propertyName: name,
+        constantName: name.toUpperCase(),
+        fileName: name,
+      })),
+      getDMMF: vi.fn().mockResolvedValue(dmmf),
+      apiLibraryGenerator: vi.fn().mockResolvedValue(undefined),
+      getPrismaSchemaPath: vi.fn(() => 'prisma/schema.prisma'),
+      readPrismaSchema: vi.fn(
+        () => `
+        /// @crudAuth: { "create": "public", "readMany": "user" }
+        model User {
+          id Int @id
+          name String
+        }
+      `,
+      ),
+      getNpmScope: vi.fn(() => 'testscope'),
+      // FIX: Add the missing mock for 'pluralize'
+      pluralize: vi.fn((name: string) => (name.endsWith('s') ? name : name + 's')),
+    }
+    vi.clearAllMocks()
+  })
+
+  it('returns early if no Prisma models are found', async () => {
+    mockDependencies.getDMMF = vi.fn().mockResolvedValue({ datamodel: { models: [] } })
+
+    // The test now correctly calls the exported logic function
+    const result = await generateCrudLogic(tree, { name: 'crud' }, mockDependencies)
+
+    expect(result).toBeUndefined()
+    expect(mockDependencies.apiLibraryGenerator).not.toHaveBeenCalled()
+    expect(mockDependencies.generateFiles).not.toHaveBeenCalled()
+  })
+
+  it('generates files and calls utilities for valid models', async () => {
+    const callback = await generateCrudLogic(tree, { name: 'crud' }, mockDependencies)
+
+    expect(mockDependencies.apiLibraryGenerator).toHaveBeenCalled()
+    expect(mockDependencies.generateFiles).toHaveBeenCalled()
+    expect(mockDependencies.formatFiles).toHaveBeenCalled()
+
+    expect(typeof callback).toBe('function')
+    if (callback) callback()
+    expect(mockDependencies.installPackagesTask).toHaveBeenCalled()
+  })
+})

package/src/generate-crud/generator.ts

@@ -0,0 +1,354 @@
+import { formatFiles, generateFiles, installPackagesTask, joinPathFragments, names, Tree } from '@nx/devkit'
+import { getDMMF } from '@prisma/internals'
+import { apiLibraryGenerator, getPrismaSchemaPath, readPrismaSchema } from '@nestledjs/utils'
+import { GenerateCrudGeneratorSchema } from './schema'
+import { getNpmScope } from '@nx/js/src/utils/package-json/get-npm-scope'
+import pluralize from 'pluralize'
+
+// STEP 1: DEFINE INTERFACES FOR DATA AND DEPENDENCIES
+interface CrudAuthConfig {
+  readOne?: string
+  readMany?: string
+  count?: string
+  create?: string
+  update?: string
+  delete?: string
+}
+
+interface ModelType {
+  name: string
+  pluralName: string
+  fields: ReadonlyArray<Record<string, unknown> & { name: string; type: string }>
+  primaryField: string
+  modelName: string
+  modelPropertyName: string
+  pluralModelName: string
+  pluralModelPropertyName: string
+  auth?: CrudAuthConfig
+}
+
+// This interface makes the generator logic testable by defining its external dependencies.
+export interface GenerateCrudGeneratorDependencies {
+  formatFiles: typeof formatFiles
+  generateFiles: typeof generateFiles
+  installPackagesTask: typeof installPackagesTask
+  joinPathFragments: typeof joinPathFragments
+  names: typeof names
+  getDMMF: typeof getDMMF
+  apiLibraryGenerator: typeof apiLibraryGenerator
+  getPrismaSchemaPath: typeof getPrismaSchemaPath
+  readPrismaSchema: typeof readPrismaSchema
+  getNpmScope: typeof getNpmScope
+  pluralize: typeof pluralize
+}
+
+// STEP 2: DEFINE PURE HELPER & CONTENT GENERATION FUNCTIONS
+// These functions are side-effect free and can be tested independently.
+
+export function parseCrudAuth(comment: string): CrudAuthConfig | null {
+  try {
+    const match = comment.match(/@crudAuth:\s*(\{.*\})/)
+    if (!match) return null
+    return JSON.parse(match[1])
+  } catch (e) {
+    console.error('Error parsing @crudAuth:', e)
+    return null
+  }
+}
+
+export function getCrudAuthForModel(schema: string, modelName: string): CrudAuthConfig {
+  const defaultConfig: CrudAuthConfig = {
+    readOne: 'admin',
+    readMany: 'admin',
+    count: 'admin',
+    create: 'admin',
+    update: 'admin',
+    delete: 'admin',
+  }
+  const lines = schema.split('\n')
+  let modelDoc: string[] = []
+  let foundModel = false
+  for (const line of lines) {
+    const trimmedLine = line.trim()
+    if (
+      trimmedLine.startsWith(`model ${modelName}`) ||
+      trimmedLine.startsWith(`model ${modelName} `) ||
+      trimmedLine.startsWith(`model ${modelName}{`)
+    ) {
+      foundModel = true
+      break
+    } else if (trimmedLine.startsWith('model ')) {
+      modelDoc = []
+    } else if (trimmedLine.startsWith('///') && !foundModel) {
+      modelDoc.push(trimmedLine)
+    }
+  }
+  if (!foundModel) return defaultConfig
+  const authLine = modelDoc.find((line) => line.includes('@crudAuth:'))
+  if (!authLine) return defaultConfig
+  const config = parseCrudAuth(authLine)
+  return config ? { ...defaultConfig, ...config } : defaultConfig
+}
+
+export function getGuardForAuthLevel(level: string): string | null {
+  if (!level) return 'GqlAuthAdminGuard'
+  level = level.toLowerCase()
+  if (level === 'public') return null
+  if (level === 'user') return 'GqlAuthGuard'
+  if (level === 'admin') return 'GqlAuthAdminGuard'
+  const pascalCase = level.charAt(0).toUpperCase() + level.slice(1).toLowerCase()
+  return `GqlAuth${pascalCase}Guard`
+}
+
+function toKebabCase(str: string): string {
+  return str.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase()
+}
+
+export function generateResolverContent(model: ModelType, npmScope: string): string {
+  const usedGuards = new Set<string>()
+  if (model.auth) {
+    Object.values(model.auth).forEach((level) => {
+      if (level === 'public') return
+      const guard = getGuardForAuthLevel(level)
+      if (guard) usedGuards.add(guard)
+    })
+  } else {
+    usedGuards.add('GqlAuthAdminGuard')
+  }
+
+  const guardImports =
+    usedGuards.size > 0 ? `import { ${Array.from(usedGuards).sort().join(', ')} } from '@${npmScope}/api/utils'` : ''
+
+  const readManyGuardDecorator = model.auth?.readMany ? getGuardForAuthLevel(model.auth.readMany) : 'GqlAuthAdminGuard'
+  const countGuardDecorator = model.auth?.count ? getGuardForAuthLevel(model.auth.count) : 'GqlAuthAdminGuard'
+  const readOneGuardDecorator = model.auth?.readOne ? getGuardForAuthLevel(model.auth.readOne) : 'GqlAuthAdminGuard'
+  const createGuardDecorator = model.auth?.create ? getGuardForAuthLevel(model.auth.create) : 'GqlAuthAdminGuard'
+  const updateGuardDecorator = model.auth?.update ? getGuardForAuthLevel(model.auth.update) : 'GqlAuthAdminGuard'
+  const deleteGuardDecorator = model.auth?.delete ? getGuardForAuthLevel(model.auth.delete) : 'GqlAuthAdminGuard'
+
+  const readManyMethodName = model.pluralModelPropertyName
+  const countMethodName = `${model.pluralModelPropertyName}Count`
+  const readOneMethodName = model.modelPropertyName
+
+  return `import { Args, Mutation, Query, Resolver, Info } from '@nestjs/graphql'
+import { UseGuards } from '@nestjs/common'
+import type { GraphQLResolveInfo } from 'graphql'
+import { CorePaging } from '@${npmScope}/api/core/data-access'
+import { ApiCrudDataAccessService } from '@${npmScope}/api/generated-crud/data-access'
+import { ${model.modelName} } from '@${npmScope}/api/core/models'
+import { Create${model.modelName}Input, List${model.modelName}Input, Update${
+    model.modelName
+  }Input } from '@${npmScope}/api/generated-crud/data-access'
+${guardImports}
+
+@Resolver(() => ${model.modelName})
+export class Generated${model.modelName}Resolver {
+  constructor(private readonly service: ApiCrudDataAccessService) {}
+
+  @Query(() => [${model.modelName}], { nullable: true })
+  ${readManyGuardDecorator ? `@UseGuards(${readManyGuardDecorator})` : ''}
+  ${readManyMethodName}(
+    @Info() info: GraphQLResolveInfo,
+    @Args({ name: 'input', type: () => List${model.modelName}Input, nullable: true }) input?: List${
+    model.modelName
+  }Input,
+  ) {
+    return this.service.${readManyMethodName}(info, input)
+  }
+
+  @Query(() => CorePaging, { nullable: true })
+  ${countGuardDecorator ? `@UseGuards(${countGuardDecorator})` : ''}
+  ${countMethodName}(
+    @Args({ name: 'input', type: () => List${model.modelName}Input, nullable: true }) input?: List${
+    model.modelName
+  }Input,
+  ) {
+    return this.service.${countMethodName}(input)
+  }
+
+  @Query(() => ${model.modelName}, { nullable: true })
+  ${readOneGuardDecorator ? `@UseGuards(${readOneGuardDecorator})` : ''}
+  ${readOneMethodName}(
+    @Info() info: GraphQLResolveInfo,
+    @Args('${model.modelPropertyName}Id') ${model.modelPropertyName}Id: string
+  ) {
+    return this.service.${readOneMethodName}(info, ${model.modelPropertyName}Id)
+  }
+
+  @Mutation(() => ${model.modelName}, { nullable: true })
+  ${createGuardDecorator ? `@UseGuards(${createGuardDecorator})` : ''}
+  create${model.modelName}(
+    @Info() info: GraphQLResolveInfo,
+    @Args('input') input: Create${model.modelName}Input,
+  ) {
+    return this.service.create${model.modelName}(info, input)
+  }
+
+  @Mutation(() => ${model.modelName}, { nullable: true })
+  ${updateGuardDecorator ? `@UseGuards(${updateGuardDecorator})` : ''}
+  update${model.modelName}(
+    @Info() info: GraphQLResolveInfo,
+    @Args('${model.modelPropertyName}Id') ${model.modelPropertyName}Id: string,
+    @Args('input') input: Update${model.modelName}Input,
+  ) {
+    return this.service.update${model.modelName}(info, ${model.modelPropertyName}Id, input)
+  }
+
+  @Mutation(() => ${model.modelName}, { nullable: true })
+  ${deleteGuardDecorator ? `@UseGuards(${deleteGuardDecorator})` : ''}
+  delete${model.modelName}(
+    @Args('${model.modelPropertyName}Id') ${model.modelPropertyName}Id: string,
+  ) {
+    return this.service.delete${model.modelName}(${model.modelPropertyName}Id)
+  }
+}
+`
+}
+
+export function generateFeatureModuleContent(models: ModelType[], npmScope: string): string {
+  return `import { Module } from '@nestjs/common'\nimport { ApiCrudDataAccessModule } from '@${npmScope}/api/generated-crud/data-access'\n${models
+    .map((model) => `import { Generated${model.modelName}Resolver } from './${toKebabCase(model.modelName)}.resolver'`)
+    .join('\n')}\n\n@Module({\n  imports: [ApiCrudDataAccessModule],\n  providers: [${models
+    .map((model) => `Generated${model.modelName}Resolver`)
+    .join(', ')}],\n})\nexport class ApiGeneratedCrudFeatureModule {}\n`
+}
+
+export function generateFeatureIndexContent(models: ModelType[]): string {
+  return `export * from './lib/api-admin-crud-feature.module'\n${models
+    .map((model) => `export * from './lib/${toKebabCase(model.modelName)}.resolver'`)
+    .join('\n')}\n`
+}
+
+// STEP 3: DEFINE THE CORE LOGIC FUNCTION
+// This function contains all the generator's logic but uses injected dependencies, making it testable.
+export async function generateCrudLogic(
+  tree: Tree,
+  schema: GenerateCrudGeneratorSchema,
+  dependencies: GenerateCrudGeneratorDependencies,
+) {
+  // Helper functions that now use injected dependencies
+  async function getAllPrismaModels(tree: Tree): Promise<ModelType[]> {
+    const prismaPath = dependencies.getPrismaSchemaPath(tree)
+    const prismaSchema = dependencies.readPrismaSchema(tree, prismaPath)
+    if (!prismaSchema) {
+      console.error(`No Prisma schema found at ${prismaPath}`)
+      return []
+    }
+    try {
+      const dmmf = await dependencies.getDMMF({ datamodel: prismaSchema })
+      return dmmf.datamodel.models.map((model) => {
+        const singularPropertyName = model.name.charAt(0).toLowerCase() + model.name.slice(1)
+        const pluralPropertyName = dependencies.pluralize(singularPropertyName)
+        const authConfig = getCrudAuthForModel(prismaSchema, model.name)
+        return {
+          name: model.name,
+          pluralName: dependencies.pluralize(model.name),
+          fields: model.fields.map((field) => ({ ...field })),
+          primaryField: model.fields.find((f) => !f.isId && f.type === 'String')?.name || 'name',
+          modelName: model.name,
+          modelPropertyName: singularPropertyName,
+          pluralModelName: dependencies.pluralize(model.name),
+          pluralModelPropertyName: pluralPropertyName,
+          auth: authConfig,
+        }
+      })
+    } catch (error) {
+      console.error('Error parsing Prisma schema:', error)
+      return []
+    }
+  }
+
+  async function createLibraries(tree: Tree, name: string) {
+    const dataAccessLibraryRoot = `libs/api/${name}/data-access`
+    const featureLibraryRoot = `libs/api/${name}/feature`
+    const dataAccessTemplatePath = dependencies.joinPathFragments(__dirname, './files/data-access')
+    const featureTemplatePath = dependencies.joinPathFragments(__dirname, './files/feature')
+    await dependencies.apiLibraryGenerator(tree, { name }, dataAccessTemplatePath, 'data-access')
+    await dependencies.apiLibraryGenerator(tree, { name }, featureTemplatePath, 'feature')
+    return { dataAccessLibraryRoot, featureLibraryRoot }
+  }
+
+  async function generateModelFiles(
+    tree: Tree,
+    dataAccessLibraryRoot: string,
+    featureLibraryRoot: string,
+    models: ModelType[],
+    name: string,
+  ) {
+    const npmScope = dependencies.getNpmScope(tree)
+    const nameObj = dependencies.names(name)
+    const substitutions = { ...nameObj, name, models, npmScope: `@${npmScope}`, apiClassName: 'PrismaCrud', tmpl: '' }
+
+    dependencies.generateFiles(
+      tree,
+      dependencies.joinPathFragments(__dirname, './files/data-access/src/lib'),
+      dependencies.joinPathFragments(dataAccessLibraryRoot, 'src/lib'),
+      { ...substitutions, type: 'data-access' },
+    )
+    dependencies.generateFiles(
+      tree,
+      dependencies.joinPathFragments(__dirname, './files/data-access/src'),
+      dependencies.joinPathFragments(dataAccessLibraryRoot, 'src'),
+      { ...substitutions, type: 'data-access' },
+    )
+
+    const featureModuleContent = generateFeatureModuleContent(models, npmScope)
+    tree.write(
+      dependencies.joinPathFragments(featureLibraryRoot, 'src/lib/api-admin-crud-feature.module.ts'),
+      featureModuleContent,
+    )
+
+    const featureIndexContent = generateFeatureIndexContent(models)
+    tree.write(dependencies.joinPathFragments(featureLibraryRoot, 'src/index.ts'), featureIndexContent)
+
+    for (const model of models) {
+      const resolverFilePath = dependencies.joinPathFragments(
+        featureLibraryRoot,
+        `src/lib/${toKebabCase(model.modelName)}.resolver.ts`,
+      )
+      const resolverContent = generateResolverContent(model, npmScope)
+      tree.write(resolverFilePath, resolverContent)
+    }
+  }
+
+  // Main Orchestration Logic
+  const name = schema.name || 'generated-crud'
+  const models = await getAllPrismaModels(tree)
+  if (models.length === 0) {
+    console.error('No Prisma models found')
+    return // Return early for the test case
+  }
+
+  const { dataAccessLibraryRoot, featureLibraryRoot } = await createLibraries(tree, name)
+  await generateModelFiles(tree, dataAccessLibraryRoot, featureLibraryRoot, models, name)
+  await dependencies.formatFiles(tree)
+
+  return () => {
+    dependencies.installPackagesTask(tree)
+  }
+}
+
+// STEP 4: DEFINE THE DEFAULT EXPORT
+// This is what Nx CLI executes. It's a simple wrapper that provides the *real* dependencies to the logic function.
+export default async function (tree: Tree, schema: GenerateCrudGeneratorSchema) {
+  const dependencies: GenerateCrudGeneratorDependencies = {
+    formatFiles,
+    generateFiles,
+    installPackagesTask,
+    joinPathFragments,
+    names,
+    getDMMF,
+    apiLibraryGenerator,
+    getPrismaSchemaPath,
+    readPrismaSchema,
+    getNpmScope,
+    pluralize,
+  }
+
+  try {
+    return await generateCrudLogic(tree, schema, dependencies)
+  } catch (error) {
+    console.error('Error in CRUD generator:', error)
+    throw error
+  }
+}