@nestledjs/api 0.0.6 → 0.0.8

package/src/app/generator.spec.ts

@@ -1,112 +0,0 @@
-import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing'
-import { Tree } from '@nx/devkit'
-import { execSync } from 'child_process'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import generator from './generator'
-
-vi.mock('child_process', async (importOriginal) => {
-  const originalModule = await importOriginal()
-  return {
-    ...(originalModule as object),
-    execSync: vi.fn(),
-  }
-})
-
-describe('api generator', () => {
-  let tree: Tree
-  const mockedExecSync = execSync as ReturnType<(typeof vi)['fn']>
-
-  beforeEach(() => {
-    tree = createTreeWithEmptyWorkspace()
-    tree.write('package.json', JSON.stringify({ name: 'test-repo', scripts: {} }))
-
-    mockedExecSync.mockImplementation((command: string) => {
-      if (command.startsWith('nx g @nx/nest:application')) {
-        tree.write(
-          'apps/api/webpack.config.js',
-          `
-const path = require('path');
-const { composePlugins, withNx } = require('@nx/webpack');
-
-module.exports = composePlugins(withNx(), (config) => {
-  return {
-    ...config,
-    output: {
-      ...config.output,
-      devtoolModuleFilenameTemplate: (info) => {
-        const rel = path.relative(process.cwd(), info.absoluteResourcePath);
-        return \`webpack://\${rel}\`;
-      },
-    },
-    assets: ['./src/assets'],
-    generatePackageJson: true,
-  };
-});`
-        )
-        // Add a mock tsconfig.app.json file with the compiler options we want to remove
-        tree.write('apps/api/tsconfig.app.json', JSON.stringify({
-          extends: '../../tsconfig.base.json',
-          compilerOptions: {
-            module: 'commonjs',
-            moduleResolution: 'node',
-            emitDecoratorMetadata: true,
-            experimentalDecorators: true,
-            outDir: '../../dist/out-tsc',
-            declaration: true,
-            types: ['node']
-          },
-          exclude: ['jest.config.ts', '**/*.spec.ts', '**/*.test.ts'],
-          include: ['**/*.ts']
-        }, null, 2))
-        tree.write('apps/api/src/app/.gitkeep', '')
-        tree.write('apps/api/src/assets/.gitkeep', '')
-      }
-      return ''
-    })
-
-    vi.spyOn(console, 'log').mockImplementation(() => { /* empty */ })
-    vi.spyOn(console, 'warn').mockImplementation(() => { /* empty */ })
-    vi.spyOn(console, 'error').mockImplementation(() => { /* empty */ })
-  })
-
-  afterEach(() => {
-    vi.restoreAllMocks()
-    mockedExecSync.mockClear()
-  })
-
-  it('should run successfully', async () => {
-    await generator(tree, {})
-
-    expect(mockedExecSync).toHaveBeenCalledWith(
-      'nx g @nx/nest:application --name api --directory apps/api --no-interactive',
-      {
-        stdio: 'inherit',
-        cwd: tree.root,
-      }
-    )
-
-    const webpackConfig = tree.read('apps/api/webpack.config.js', 'utf-8')
-    expect(webpackConfig).not.toContain("assets: ['./src/assets']")
-
-    const packageJson = JSON.parse(tree.read('package.json', 'utf-8'))
-    expect(packageJson.scripts['dev:api']).toBe('nx serve api --skip-nx-cache')
-
-    expect(tree.exists('apps/api/src/app')).toBe(false)
-    expect(tree.exists('apps/api/src/assets')).toBe(false)
-
-    expect(tree.exists('apps/api/src/app.config.ts')).toBe(true)
-    expect(tree.exists('apps/api/src/app.module.ts')).toBe(true)
-    expect(tree.exists('apps/api/src/applogger.middleware.ts')).toBe(true)
-    expect(tree.exists('apps/api/src/main.ts')).toBe(true)
-
-    // Verify that the compiler options are removed from tsconfig.app.json
-    const tsConfig = JSON.parse(tree.read('apps/api/tsconfig.app.json', 'utf-8'))
-    expect(tsConfig.compilerOptions.module).toBeUndefined()
-    expect(tsConfig.compilerOptions.moduleResolution).toBeUndefined()
-    expect(tsConfig.compilerOptions.emitDecoratorMetadata).toBeUndefined()
-    expect(tsConfig.compilerOptions.experimentalDecorators).toBeUndefined()
-    // Verify that other compiler options are preserved
-    expect(tsConfig.compilerOptions.outDir).toBe('../../dist/out-tsc')
-    expect(tsConfig.compilerOptions.declaration).toBe(true)
-  })
-})

package/src/app/generator.ts

@@ -1,105 +0,0 @@
-import { generateFiles, joinPathFragments, Tree, updateJson } from '@nx/devkit'
-import { execSync } from 'child_process'
-import * as path from 'path'
-import { getNpmScope } from '@nx/js/src/utils/package-json/get-npm-scope'
-
-/**
- * Removes specific compiler options from tsconfig.app.json to use the settings from tsconfig.base.json
- * @param tree The file system tree
- */
-function updateAppTsConfig(tree: Tree): void {
-  const tsConfigPath = 'apps/api/tsconfig.app.json'
-  if (tree.exists(tsConfigPath)) {
-    updateJson(tree, tsConfigPath, (json) => {
-      if (json.compilerOptions) {
-        // Remove specific options to use the ones from tsconfig.base.json
-        delete json.compilerOptions.module
-        delete json.compilerOptions.moduleResolution
-        delete json.compilerOptions.emitDecoratorMetadata
-        delete json.compilerOptions.experimentalDecorators
-      }
-      return json
-    })
-  } else {
-    console.warn(`tsconfig.app.json not found at: ${tsConfigPath}`)
-  }
-}
-
-interface Schema {
-  [key: string]: unknown
-}
-
-export default async function (tree: Tree, schema: Schema) {
-  try {
-    // Get the workspace root directory
-    const workspaceRoot = tree.root
-
-    // Create apps directory if it doesn't exist
-    if (!tree.exists('apps')) {
-      tree.write('apps/.gitkeep', '')
-    }
-
-    // Run the Nx generator command directly from the workspace root with proper workspace layout
-    execSync('nx g @nx/nest:application --name api --directory apps/api --no-interactive', {
-      stdio: 'inherit',
-      cwd: workspaceRoot,
-    })
-
-    // Wait a bit for files to be created
-    await new Promise((resolve) => setTimeout(resolve, 2000))
-
-    // Update tsconfig.app.json to remove specific compiler options
-    updateAppTsConfig(tree)
-
-    // Generate all files according to the template folder structure
-    generateFiles(
-      tree,
-      joinPathFragments(__dirname, './files'),
-      path.join('apps', 'api'),
-      { ...schema, tmpl: '', npmScope: getNpmScope(tree) }
-    );
-
-    // Add dev:api script to package.json
-    updateJson(tree, 'package.json', (json) => {
-      if (!json.scripts) {
-        json.scripts = {}
-      }
-      json.scripts['dev:api'] = 'nx serve api --skip-nx-cache'
-      return json
-    })
-
-    // Update the build target in apps/api/project.json to use custom webpack command
-    const projectJsonPath = path.join('apps', 'api', 'project.json')
-    if (tree.exists(projectJsonPath)) {
-      updateJson(tree, projectJsonPath, (json) => {
-        json.targets = json.targets || {}
-        json.targets.build = {
-          executor: 'nx:run-commands',
-          options: {
-            command: 'NODE_ENV=production webpack-cli --config apps/api/webpack.config.js',
-          },
-          configurations: {
-            development: {
-              command: 'NODE_ENV=development webpack-cli --config apps/api/webpack.config.js',
-            },
-          },
-        }
-        return json
-      })
-    } else {
-      console.warn(`project.json not found at: ${projectJsonPath}`)
-    }
-
-    // Optionally, delete the unused default app files if they exist
-    const targetPath = path.join('apps', 'api', 'src')
-    const filesToDelete = [path.join(targetPath, 'assets'), path.join(targetPath, 'app')]
-    filesToDelete.forEach((filePath) => {
-      if (tree.exists(filePath)) {
-        tree.delete(filePath)
-      }
-    })
-  } catch (error) {
-    console.error('Error generating API app:', error)
-    throw error
-  }
-}

package/src/config/generator.spec.ts

@@ -1,47 +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('config generator', () => {
-  let tree: Tree
-
-  beforeEach(() => {
-    tree = createTreeWithEmptyWorkspace()
-  })
-
-  it('should run successfully', async () => {
-    const callback = await generator(tree)
-    callback()
-
-    expect(apiLibraryGenerator).toHaveBeenCalledWith(tree, { name: 'config', 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 () => {
-    const callback = await generator(tree, { overwrite: true })
-    callback()
-
-    expect(apiLibraryGenerator).toHaveBeenCalledWith(tree, { name: 'config', overwrite: true }, expect.any(String))
-  })
-})

package/src/config/generator.ts

@@ -1,16 +0,0 @@
-import { formatFiles, installPackagesTask, joinPathFragments, Tree } from '@nx/devkit'
-import { apiLibraryGenerator } from '@nestledjs/utils'
-import { ApiConfigGeneratorSchema } from './schema'
-
-export default async function generateLibraries(tree: Tree, options: ApiConfigGeneratorSchema = {}) {
-  const templateRootPath = joinPathFragments(__dirname, './files')
-  const overwrite = options.overwrite === true
-
-  await apiLibraryGenerator(tree, { name: 'config', overwrite }, templateRootPath)
-
-  await formatFiles(tree)
-
-  return () => {
-    installPackagesTask(tree)
-  }
-}

package/src/core/generator.spec.ts

@@ -1,85 +0,0 @@
-import { formatFiles, installPackagesTask, Tree } from '@nx/devkit'
-import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing'
-import { describe, expect, it, vi } from 'vitest'
-import { apiLibraryGenerator, installPlugins } from '@nestledjs/utils'
-
-import generator from './generator'
-
-vi.mock('@nestledjs/utils', async () => {
-  const actual = await vi.importActual('@nestledjs/utils')
-  return {
-    ...actual,
-    apiLibraryGenerator: vi.fn(),
-    installPlugins: vi.fn(),
-  }
-})
-
-vi.mock('@nx/devkit', async () => {
-  const actual = await vi.importActual('@nx/devkit')
-  return {
-    ...actual,
-    formatFiles: vi.fn(),
-    installPackagesTask: vi.fn(),
-  }
-})
-
-describe('core generator', () => {
-  let tree: Tree
-
-  beforeEach(() => {
-    tree = createTreeWithEmptyWorkspace()
-  })
-
-  it('should run successfully', async () => {
-    const callback = await generator(tree)
-    callback()
-
-    expect(installPlugins).toHaveBeenCalled()
-    expect(apiLibraryGenerator).toHaveBeenCalledWith(
-      tree,
-      { name: 'core', overwrite: false },
-      expect.any(String),
-      'data-access',
-    )
-    expect(apiLibraryGenerator).toHaveBeenCalledWith(
-      tree,
-      { name: 'core', overwrite: false },
-      expect.any(String),
-      'feature',
-      true,
-    )
-    expect(apiLibraryGenerator).toHaveBeenCalledWith(
-      tree,
-      { name: 'core', overwrite: false },
-      expect.any(String),
-      'models',
-    )
-    expect(formatFiles).toHaveBeenCalledWith(tree)
-    expect(installPackagesTask).toHaveBeenCalledWith(tree)
-  })
-
-  it('should pass overwrite flag to apiLibraryGenerator when overwrite is true', async () => {
-    const callback = await generator(tree, { overwrite: true })
-    callback()
-
-    expect(apiLibraryGenerator).toHaveBeenCalledWith(
-      tree,
-      { name: 'core', overwrite: true },
-      expect.any(String),
-      'data-access',
-    )
-    expect(apiLibraryGenerator).toHaveBeenCalledWith(
-      tree,
-      { name: 'core', overwrite: true },
-      expect.any(String),
-      'feature',
-      true,
-    )
-    expect(apiLibraryGenerator).toHaveBeenCalledWith(
-      tree,
-      { name: 'core', overwrite: true },
-      expect.any(String),
-      'models',
-    )
-  })
-})

package/src/core/generator.ts

@@ -1,35 +0,0 @@
-import { formatFiles, GeneratorCallback, installPackagesTask, joinPathFragments, Tree } from '@nx/devkit'
-import { apiLibraryGenerator, installPlugins } from '@nestledjs/utils'
-import { ApiCoreGeneratorSchema } from './schema'
-
-export default async function generateLibraries(
-  tree: Tree,
-  options: ApiCoreGeneratorSchema = {},
-): Promise<GeneratorCallback> {
-  const templateRootPath = joinPathFragments(__dirname, './files')
-  const overwrite = options.overwrite === true
-
-  const dependencies = {
-    'graphql-type-json': '^0.3.2',
-    '@nestjs/graphql': '^12.0.0',
-    '@nestjs/common': '^10.0.0',
-    '@nestjs/passport': '^10.0.0',
-    '@nestjs/axios': '^3.0.0',
-    '@prisma/client': '^6.9.0',
-    '@apollo/server': '^4.9.0',
-  }
-
-  const devDependencies = {}
-
-  await installPlugins(tree, dependencies, devDependencies)
-
-  await apiLibraryGenerator(tree, { name: 'core', overwrite }, templateRootPath, 'data-access')
-  await apiLibraryGenerator(tree, { name: 'core', overwrite }, templateRootPath, 'feature', true)
-  await apiLibraryGenerator(tree, { name: 'core', overwrite }, templateRootPath, 'models')
-
-  await formatFiles(tree)
-
-  return () => {
-    installPackagesTask(tree)
-  }
-}

package/src/custom/generator.spec.ts

@@ -1,75 +0,0 @@
-import { Tree } from '@nx/devkit'
-import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing'
-import { vi, describe, it, expect, beforeEach } from 'vitest'
-import { customGeneratorLogic, CustomGeneratorDependencies } from './generator'
-
-const dmmf = {
-  datamodel: {
-    models: [
-      {
-        name: 'User',
-        fields: [
-          { name: 'id', type: 'Int', isId: true },
-          { name: 'name', type: 'String' },
-        ],
-      },
-    ],
-  },
-}
-
-describe('custom-generator', () => {
-  let tree: Tree
-  let mockDependencies: CustomGeneratorDependencies
-
-  beforeEach(() => {
-    tree = createTreeWithEmptyWorkspace()
-    mockDependencies = {
-      formatFiles: vi.fn(),
-      installPackagesTask: vi.fn(),
-      getDMMF: vi.fn().mockResolvedValue(dmmf),
-      addToModules: vi.fn(),
-      apiLibraryGenerator: vi.fn(),
-      getPrismaSchemaPath: vi.fn(() => 'prisma/schema.prisma'),
-      readPrismaSchema: vi.fn(() => `model User {}`),
-      execSync: vi.fn(),
-      getNpmScope: vi.fn(() => 'test-scope'),
-      pluralize: vi.fn((name: string) => (name.endsWith('s') ? name : name + 's')) as any,
-      join: vi.fn((...args: string[]) => args.join('/')),
-    }
-    vi.clearAllMocks()
-  })
-
-  it('should generate files correctly', async () => {
-    await customGeneratorLogic(tree, { name: 'custom' }, mockDependencies)
-    expect(mockDependencies.apiLibraryGenerator).toHaveBeenCalledWith(
-      tree,
-      { name: 'custom' },
-      '',
-      undefined,
-      false,
-    )
-    // Check if files are generated in the new structure
-    expect(tree.exists('libs/api/custom/src/lib/default/user/user.service.ts')).toBe(true)
-    expect(tree.exists('libs/api/custom/src/lib/default/user/user.resolver.ts')).toBe(true)
-    expect(tree.exists('libs/api/custom/src/lib/default/user/user.module.ts')).toBe(true)
-    expect(tree.exists('libs/api/custom/src/index.ts')).toBe(true)
-    expect(tree.exists('libs/api/custom/src/lib/plugins')).toBe(true)
-  })
-
-  it('should be idempotent and not overwrite existing model folders', async () => {
-    // First run
-    await customGeneratorLogic(tree, { name: 'custom' }, mockDependencies)
-    // Write a marker file to simulate user customization
-    tree.write('libs/api/custom/src/lib/default/user/custom.txt', 'do not overwrite')
-    // Second run
-    await customGeneratorLogic(tree, { name: 'custom' }, mockDependencies)
-    // The marker file should still exist
-    expect(tree.read('libs/api/custom/src/lib/default/user/custom.txt', 'utf-8')).toBe('do not overwrite')
-  })
-
-  it('should not generate files if no models are found', async () => {
-    mockDependencies.getDMMF = vi.fn().mockResolvedValue({ datamodel: { models: [] } })
-    await customGeneratorLogic(tree, { name: 'custom' }, mockDependencies)
-    expect(mockDependencies.execSync).not.toHaveBeenCalled()
-  })
-})