@nestledjs/api 0.0.6 → 0.0.8

package/src/generate-crud/generator.ts

@@ -1,354 +0,0 @@
-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
-  }
-}

package/src/generate-crud/schema.ts

@@ -1,8 +0,0 @@
-export interface GenerateCrudGeneratorSchema {
-  name: string;
-  directory: string;
-  model: string;
-  plural: string;
-  description?: string;
-  overwrite?: boolean;
-}

package/src/index.ts

@@ -1,13 +0,0 @@
-export * from './account/generator'
-export * from './app/generator'
-export * from './config/generator'
-export * from './core/generator'
-export * from './custom/generator'
-export * from './generate-crud/generator'
-export * from './smtp-mailer/generator'
-export * from './prisma/generator'
-export * from './setup/generator'
-export * from './user/generator'
-export * from './workspace-setup/generator'
-export * from './plugin/generator'
-export * from './utils/generator'

package/src/plugin/generator.spec.ts

@@ -1,18 +0,0 @@
-import { Tree } from '@nx/devkit'
-import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing'
-import generator from './generator'
-
-describe('plugin-generator', () => {
-  let tree: Tree
-
-  beforeEach(() => {
-    tree = createTreeWithEmptyWorkspace()
-  })
-
-  it('should generate plugin files in the plugins folder', async () => {
-    await generator(tree, { name: 'TestPlugin' })
-    expect(tree.exists('libs/api/custom/src/lib/plugins/test-plugin/test-plugin.service.ts')).toBe(true)
-    expect(tree.exists('libs/api/custom/src/lib/plugins/test-plugin/test-plugin.resolver.ts')).toBe(true)
-    expect(tree.exists('libs/api/custom/src/lib/plugins/test-plugin/test-plugin.module.ts')).toBe(true)
-  })
-}) 

package/src/plugin/generator.ts

@@ -1,74 +0,0 @@
-import { formatFiles, installPackagesTask, Tree } from '@nx/devkit'
-import { join } from 'path'
-import { GeneratePluginGeneratorSchema } from './schema'
-
-function toKebabCase(str: string): string {
-  return str
-    .replace(/([a-z])([A-Z])/g, '$1-$2')
-    .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
-    .toLowerCase()
-}
-
-function toPascalCase(str: string): string {
-  return str
-    .replace(/(^\w|[-_\s]\w)/g, (match) => match.replace(/[-_\s]/, '').toUpperCase())
-}
-
-async function ensureDirExists(tree: Tree, path: string) {
-  if (!tree.exists(path)) {
-    // Directory will be created when a file is written into it
-  }
-}
-
-export default async function (tree: Tree, schema: GeneratePluginGeneratorSchema) {
-  const name = schema.name
-  if (!name) throw new Error('Name is required')
-  const kebabName = toKebabCase(name)
-  const className = toPascalCase(name)
-  const customLibraryRoot = schema.directory ? `libs/api/${schema.directory}/custom` : `libs/api/custom`
-  const pluginsDir = join(customLibraryRoot, 'src/lib/plugins')
-  const pluginFolder = join(pluginsDir, kebabName)
-
-  await ensureDirExists(tree, pluginsDir)
-  await ensureDirExists(tree, pluginFolder)
-
-  // Service
-  const serviceContent = `import { Injectable } from '@nestjs/common'
-
-@Injectable()
-export class ${className}Service {
-  // Add your service logic here
-}
-`
-  tree.write(join(pluginFolder, `${kebabName}.service.ts`), serviceContent)
-
-  // Resolver
-  const resolverContent = `import { Resolver } from '@nestjs/graphql'
-import { Injectable } from '@nestjs/common'
-
-@Resolver()
-@Injectable()
-export class ${className}Resolver {
-  // Add your resolver logic here
-}
-`
-  tree.write(join(pluginFolder, `${kebabName}.resolver.ts`), resolverContent)
-
-  // Module
-  const moduleContent = `import { Module } from '@nestjs/common'
-import { ${className}Service } from './${kebabName}.service'
-import { ${className}Resolver } from './${kebabName}.resolver'
-
-@Module({
-  providers: [${className}Service, ${className}Resolver],
-  exports: [${className}Service, ${className}Resolver],
-})
-export class ${className}Module {}
-`
-  tree.write(join(pluginFolder, `${kebabName}.module.ts`), moduleContent)
-
-  await formatFiles(tree)
-  return () => {
-    installPackagesTask(tree)
-  }
-} 

package/src/prisma/generator.spec.ts

@@ -1,60 +0,0 @@
-import { formatFiles, installPackagesTask, Tree } from '@nx/devkit'
-import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing'
-import { describe, expect, it, vi } from 'vitest'
-import { apiLibraryGenerator } from '@nestledjs/utils'
-
-import generator from './generator'
-
-vi.mock('@nestledjs/utils', async () => {
-  const actual = await vi.importActual('@nestledjs/utils')
-  return {
-    ...actual,
-    apiLibraryGenerator: vi.fn(),
-  }
-})
-
-vi.mock('@nx/devkit', async () => {
-  const actual = await vi.importActual('@nx/devkit')
-  return {
-    ...actual,
-    formatFiles: vi.fn(),
-    installPackagesTask: vi.fn(),
-  }
-})
-
-describe('prisma generator', () => {
-  let tree: Tree
-
-  beforeEach(() => {
-    tree = createTreeWithEmptyWorkspace()
-    tree.write('package.json', JSON.stringify({ name: 'test' }))
-  })
-
-  it('should run successfully', async () => {
-    const callback = await generator(tree)
-    callback()
-
-    const packageJson = JSON.parse(tree.read('package.json', 'utf-8'))
-
-    expect(packageJson.prisma).toEqual({
-      schema: 'libs/api/prisma/src/lib/schemas',
-      seed: 'ts-node --project libs/api/core/models/tsconfig.lib.json libs/api/prisma/src/lib/seed/seed.ts',
-    })
-
-    expect(packageJson.scripts['generate:models']).toBe(
-      'ts-node --project libs/api/core/models/tsconfig.lib.json libs/api/core/models/src/lib/generate-models.ts',
-    )
-
-    expect(apiLibraryGenerator).toHaveBeenCalledWith(tree, { name: 'prisma', overwrite: false }, expect.any(String))
-    expect(formatFiles).toHaveBeenCalledWith(tree)
-    expect(installPackagesTask).toHaveBeenCalledWith(tree)
-  })
-
-  it('should pass overwrite flag to apiLibraryGenerator when overwrite is true', async () => {
-    tree.write('package.json', JSON.stringify({ name: 'test' }))
-    const callback = await generator(tree, { overwrite: true })
-    callback()
-
-    expect(apiLibraryGenerator).toHaveBeenCalledWith(tree, { name: 'prisma', overwrite: true }, expect.any(String))
-  })
-})

package/src/prisma/generator.ts

@@ -1,61 +0,0 @@
-import { formatFiles, installPackagesTask, joinPathFragments, Tree, updateJson } from '@nx/devkit'
-import { apiLibraryGenerator } from '@nestledjs/utils'
-import { ApiPrismaGeneratorSchema } from './schema'
-
-export default async function generateLibraries(tree: Tree, options: ApiPrismaGeneratorSchema = {}) {
-  const templateRootPath = joinPathFragments(__dirname, './files')
-  const overwrite = options.overwrite === true
-
-  // Update package.json
-  updateJson(tree, 'package.json', (json) => {
-    // Add prisma schema path
-    json.prisma = {
-      schema: 'libs/api/prisma/src/lib/schemas',
-      seed: 'ts-node --project libs/api/core/models/tsconfig.lib.json libs/api/prisma/src/lib/seed/seed.ts',
-    }
-    // Add GraphQL model generation script for the 'core' library
-    if (!json.scripts) {
-      json.scripts = {}
-    }
-    if (!json.scripts['generate:models']) {
-      json.scripts['generate:models'] =
-        'ts-node --project libs/api/core/models/tsconfig.lib.json libs/api/core/models/src/lib/generate-models.ts'
-    }
-
-    // Add all requested prisma scripts if not already present
-    if (!json.scripts['prisma:apply']) {
-      json.scripts['prisma:apply'] = 'pnpm prisma:format && pnpm prisma db push'
-    }
-    if (!json.scripts['prisma:db-push']) {
-      json.scripts['prisma:db-push'] = 'pnpm prisma db push'
-    }
-    if (!json.scripts['prisma:format']) {
-      json.scripts['prisma:format'] = 'pnpm prisma format'
-    }
-    if (!json.scripts['prisma:generate']) {
-      json.scripts['prisma:generate'] = 'pnpm prisma generate'
-    }
-    if (!json.scripts['prisma:migrate']) {
-      json.scripts['prisma:migrate'] = 'pnpm prisma migrate save && pnpm prisma migrate up'
-    }
-    if (!json.scripts['prisma:seed']) {
-      json.scripts['prisma:seed'] =
-        'ts-node --project libs/api/prisma/tsconfig.lib.json libs/api/prisma/src/lib/seed/seed.ts'
-    }
-    if (!json.scripts['prisma:studio']) {
-      json.scripts['prisma:studio'] = 'pnpm nx prisma:studio api'
-    }
-    if (!json.scripts['prisma:reset']) {
-      json.scripts['prisma:reset'] = 'pnpm prisma migrate reset && pnpm prisma:seed'
-    }
-    return json
-  })
-
-  await apiLibraryGenerator(tree, { name: 'prisma', overwrite }, templateRootPath)
-
-  await formatFiles(tree)
-
-  return () => {
-    installPackagesTask(tree)
-  }
-}

package/src/setup/generator.spec.ts

@@ -1,18 +0,0 @@
-import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing'
-import { Tree } from '@nx/devkit'
-import { apiSetupGenerator } from './generator'
-
-describe('api-dependencies generator', () => {
-  let tree: Tree
-
-  beforeEach(() => {
-    tree = createTreeWithEmptyWorkspace()
-  })
-
-  it('should add required dependencies to package.json', async () => {
-    await apiSetupGenerator(tree)
-    // Note: We can't easily test package.json modifications in the tree
-    // since addDependenciesToPackageJson is mocked in tests
-    expect(tree).toBeDefined()
-  })
-})