@nestledjs/api 0.0.1

package/src/core/files/models/src/lib/generate-models.ts__tmpl__

@@ -0,0 +1,294 @@
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'fs' // Added readdirSync, lstatSync
+import { join } from 'path'
+import { execSync } from 'child_process'
+import { getDMMF } from '@prisma/internals'
+
+// Find project root and get schema path from package.json
+function findProjectRoot(startDir: string): string {
+  try {
+    // Try to use Nx's utility first if available
+    try {
+      const { findRootSync } = require('@nx/devkit')
+      return findRootSync(startDir)
+    } catch {
+      // Fallback to process.cwd() which should be project root when running scripts
+      return process.cwd()
+    }
+  } catch (error) {
+    console.error('Error finding project root:', error)
+    return process.cwd() // Fallback
+  }
+}
+
+// Determine the correct prisma import path based on package.json configuration
+function getPrismaImportPath(): string {
+  try {
+    const projectRoot = findProjectRoot(__dirname)
+    const packageJsonPath = join(projectRoot, 'package.json')
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
+
+    const schemaPathSetting = packageJson.prisma?.schema || ''
+
+    // Updated logic: if the schema path includes 'libs/api/prisma' (or similar new structure)
+    if (schemaPathSetting.includes('libs/api/prisma') || schemaPathSetting.includes('prisma/src/lib')) {
+      return '@<%= npmScope %>/api/prisma'
+    }
+
+    // Fallback to the original path if not explicitly the new structure
+    return '@<%= npmScope %>/api/core/data-access'
+  } catch (error) {
+    console.error('Error determining Prisma import path:', error)
+    // Default to the new path as a sensible fallback
+    return '@<%= npmScope %>/api/prisma'
+  }
+}
+
+// Get schema directory path from package.json
+function getPrismaSchemaDir(): string {
+  // Renamed
+  try {
+    const projectRoot = findProjectRoot(__dirname)
+    const packageJsonPath = join(projectRoot, 'package.json')
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
+
+    if (!packageJson.prisma?.schema) {
+      throw new Error('prisma.schema path not found in package.json')
+    }
+
+    // Join the project root with the schema path (which should be a directory)
+    return join(projectRoot, packageJson.prisma.schema)
+  } catch (error) {
+    console.error('Error getting Prisma schema directory path:', error)
+    // Fallback to the old directory path for backward compatibility
+    return join(__dirname, '../../../data-access/src/prisma/schemas') // Assuming this was the directory
+  }
+}
+
+// Paths
+const schemaDir = getPrismaSchemaDir() // Renamed variable
+const outputDir = join(__dirname, './models')
+const prismaImportPath = getPrismaImportPath()
+
+async function main() {
+  // Ensure output directory exists
+  if (!existsSync(outputDir)) {
+    mkdirSync(outputDir, { recursive: true })
+  }
+
+  // Verify schema directory exists and is a directory
+  if (!existsSync(schemaDir) || !lstatSync(schemaDir).isDirectory()) {
+    console.error(`Error: Prisma schema directory not found or is not a directory at ${schemaDir}`)
+    console.error('Please check your package.json prisma.schema configuration.')
+    process.exit(1)
+  }
+
+  // Generate Prisma client first (Prisma CLI handles directory schemas well)
+  console.log(`Generating Prisma client using schema files in ${schemaDir}...`)
+  // Note: Prisma CLI will look for a schema.prisma file in this dir,
+  // or process all .prisma files if it's configured for multi-file.
+  // For `prisma generate`, it's often best if there's a primary schema.prisma that imports others,
+  // or if all files are at the same level.
+  // If `prisma generate` itself fails, you might need to adjust how Prisma is set up for multi-file schemas.
+  // For now, we assume `prisma generate` works with the directory.
+  execSync(`npx prisma generate --schema "${schemaDir}"`, { stdio: 'inherit' })
+  // Alternatively, if your Prisma setup truly supports just passing the directory:
+  // execSync(`npx prisma generate --schema "${schemaDir}"`, { stdio: 'inherit' });
+  // Pick the one that works for your `prisma generate` setup. If you have a main `schema.prisma` that
+  // is just configuration and other files hold models/enums, pointing `prisma generate` to that
+  // `schema.prisma` specifically might be more robust, as it will then find the other files
+  // based on its own internal logic (like `previewFeatures = ["multiFileSchema"]`).
+  // For getDMMF, we will manually concatenate.
+
+  // Read and parse all schema files for DMMF
+  console.log('Reading Prisma schema files for DMMF generation...')
+  const schemaFiles = readdirSync(schemaDir).filter((file) => file.endsWith('.prisma'))
+
+  if (schemaFiles.length === 0) {
+    console.error(`Error: No .prisma files found in directory ${schemaDir}`)
+    process.exit(1)
+  }
+
+  let combinedSchemaContent = ''
+  console.log('Concatenating schema files:')
+  for (const file of schemaFiles) {
+    const filePath = join(schemaDir, file)
+    console.log(`  - ${filePath}`)
+    combinedSchemaContent += readFileSync(filePath, 'utf-8') + '\n\n' // Add newlines between files
+  }
+
+  const dmmf = await getDMMF({ datamodel: combinedSchemaContent })
+
+  // Extract models and enums from parsed schema
+  const models = dmmf.datamodel.models
+  const enums = dmmf.datamodel.enums
+
+  // Generate models
+  console.log('Generating TypeScript models...')
+  const modelsOutput = generateModels(models, enums)
+  writeFileSync(join(outputDir, 'models.ts'), modelsOutput)
+
+  // Generate enums
+  console.log('Generating TypeScript enums...')
+  const enumsOutput = generateEnums(enums)
+  writeFileSync(join(outputDir, 'enums.ts'), enumsOutput)
+
+  // Generate index file
+  console.log('Generating index file...')
+  const indexOutput = generateIndex()
+  writeFileSync(join(outputDir, 'index.ts'), indexOutput)
+
+  console.log('Models and enums generated successfully!')
+}
+
+function generateModels(models: readonly any[], enums: readonly any[]): string {
+  // Check if any model field uses Float
+  const usesFloat = models.some(model => model.fields.some((field: { type: string }) => field.type === 'Float'));
+  let output = `import { Field, ObjectType${usesFloat ? ', Float' : ''}, Int } from '@nestjs/graphql';\n`
+  output += `import { GraphQLJSONObject } from 'graphql-type-json';\n`
+
+  // Check if any model field uses Decimal
+  const usesDecimal = models.some(model => model.fields.some((field: { type: string }) => field.type === 'Decimal'));
+  if (usesDecimal) {
+    output += `import { Decimal } from '@prisma/client/runtime/library';\n`;
+    output += `import { GraphQLDecimal } from 'prisma-graphql-type-decimal';\n`;
+  }
+  // Ensure Prisma and enums are imported correctly
+  const enumNames = enums.map((e) => e.name)
+  output += `import { Prisma } from '${prismaImportPath}';\n`
+  if (enumNames.length > 0) {
+    output += `import { ${enumNames.join(', ')} } from './enums';\n`;
+  }
+  output += `\n`
+
+  for (const model of models) {
+    output += `@ObjectType({ description: undefined })\nexport class ${model.name} {\n` // Added description: undefined for clarity if not set
+
+    for (const field of model.fields) {
+      const isList = field.isList
+      const isEnum = field.kind === 'enum'
+      const isRelation = field.kind === 'object'
+      const originalType = field.type
+      // const isRequired = field.isRequired // Natively supported by DMMF
+
+      // DEBUG LINE
+      // console.log(`DEBUG: Processing field: ${model.name}.${field.name}, Kind: ${field.kind}, OriginalType: ${originalType}, IsList: ${isList}, IsRequired: ${isRequired}`);
+
+      let tsType = originalType
+
+      if (field.kind === 'scalar') {
+        if (originalType === 'Int' || originalType === 'Float') {
+          tsType = 'number'
+        } else if (originalType === 'Decimal') {
+          tsType = 'Decimal'
+        } else if (originalType === 'String' || originalType === 'ID') {
+          tsType = 'string'
+        } else if (originalType === 'Boolean') {
+          tsType = 'boolean'
+        } else if (originalType === 'DateTime') {
+          tsType = 'Date'
+        } else if (originalType === 'Json') {
+          tsType = 'Prisma.JsonValue'
+        } else if (originalType === 'BigInt') {
+          tsType = 'bigint' // Prisma uses bigint for BigInt
+        } else if (originalType === 'Bytes') {
+          tsType = 'Buffer' // Prisma uses Buffer for Bytes
+        }
+      } else if (field.kind === 'enum') {
+        tsType = originalType
+      } else if (field.kind === 'object') {
+        tsType = originalType
+      }
+
+      let decorator = '@Field('
+      const options: string[] = []
+      // Always add nullable: true for all fields
+      options.push('nullable: true')
+
+      // Always declare the type in the decorator
+      let decoratorType = ''
+      if (isList) {
+        let listItemGraphQLType = originalType
+        if (originalType === 'Int') listItemGraphQLType = 'Int'
+        else if (originalType === 'Float') listItemGraphQLType = 'Float'
+        else if (originalType === 'Decimal') listItemGraphQLType = 'GraphQLDecimal'
+        else if (originalType === 'Json') listItemGraphQLType = 'GraphQLJSONObject'
+        else if (isEnum || isRelation)
+          listItemGraphQLType = originalType // Assumes enum/type is registered with GraphQL
+        else if (originalType === 'DateTime') listItemGraphQLType = 'Date'
+        else if (originalType === 'Boolean') listItemGraphQLType = 'Boolean'
+        else if (originalType.toLowerCase() === 'string' || originalType === 'ID') {
+          listItemGraphQLType = 'String'
+        } else {
+          listItemGraphQLType = originalType
+        }
+        decoratorType = `() => [${listItemGraphQLType}]`
+      } else {
+        // Always declare the type for non-list fields
+        if (originalType === 'Int') decoratorType = '() => Int'
+        else if (originalType === 'Float') decoratorType = '() => Float'
+        else if (originalType === 'Decimal') decoratorType = '() => GraphQLDecimal'
+        else if (originalType === 'Json') decoratorType = '() => GraphQLJSONObject'
+        else if (isEnum || isRelation) decoratorType = `() => ${originalType}`
+        else if (originalType === 'DateTime') decoratorType = '() => Date'
+        else if (originalType === 'Boolean') decoratorType = '() => Boolean'
+        else if (originalType.toLowerCase() === 'string' || originalType === 'ID') decoratorType = '() => String'
+        else decoratorType = `() => ${originalType}`
+      }
+
+      decorator += decoratorType
+      decorator += `, { ${options.join(', ')} }`
+      decorator += ')'
+
+      output += `  ${decorator}\n`
+      // Make all fields optional regardless of isRequired value
+      const optionalMarker = '?' // Always add a question mark
+
+      // For relations, use Partial<Type> only if it's not required and can be partially loaded
+      // Otherwise, if it's a relation, it's either the full Type or Type[] or null/undefined.
+      // For simplicity, let's assume if it's a relation object, it's the Type itself.
+      // Partial is useful for inputs or update DTOs, less so for GQL ObjectTypes unless specifically designed.
+      let finalTsType = tsType
+      if (isRelation && !isList) {
+        // Single related object
+        finalTsType = `${tsType}` // Not Partial<Type> by default for GQL object types
+      }
+
+      // Never add '| null' to any field
+      output += `  ${field.name}${optionalMarker}: ${finalTsType}${isList ? '[]' : ''} | null;\n\n`
+    }
+    output += `}\n\n`
+  }
+  return output
+}
+
+function generateEnums(enums: readonly any[]): string {
+  let output = '// Generated from Prisma schema\n\n'
+  output += "import { registerEnumType } from '@nestjs/graphql';\n"
+
+  if (enums.length > 0) {
+    const enumNames = enums.map((e) => e.name).join(', ')
+    output += `import { ${enumNames} } from '${prismaImportPath}';\n\n`
+    output += `export { ${enumNames} };\n\n`
+
+    enums.forEach((enumType) => {
+      output += `registerEnumType(${enumType.name}, { name: '${enumType.name}' });\n\n`
+    })
+  } else {
+    output += '// No enums found in schema to generate.\n'
+  }
+
+  return output
+}
+
+function generateIndex(): string {
+  return `// Generated from Prisma schema
+export * from './models'
+export * from './enums'
+export * from './core-paging.model'
+`
+}
+
+main().catch((e) => {
+  console.error('Error during generation:', e)
+  process.exit(1)
+})

package/src/core/files/models/src/lib/models/core-paging.model.ts__tmpl__

@@ -0,0 +1,25 @@
+import { Field, ObjectType } from '@nestjs/graphql'
+
+@ObjectType()
+export class CorePaging {
+  @Field({ nullable: true })
+  total?: number
+
+  @Field({ nullable: true })
+  count?: number
+
+  @Field({ nullable: true })
+  take?: number
+
+  @Field({ nullable: true })
+  page?: number
+
+  @Field({ nullable: true })
+  skip?: number
+
+  @Field({ nullable: true })
+  sum?: number
+
+  @Field({ nullable: true })
+  totalSum?: number
+}

package/src/core/generator.spec.ts

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

@@ -0,0 +1,35 @@
+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/core/schema.d.ts

@@ -0,0 +1,3 @@
+export interface ApiCoreGeneratorSchema {
+  overwrite?: boolean
+}

package/src/core/schema.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "ApiCore",
+  "title": "Create the API Core library",
+  "type": "object",
+  "properties": {
+    "overwrite": {
+      "type": "boolean",
+      "description": "Whether to overwrite existing core libraries if they exist.",
+      "default": false
+    }
+  }
+}

package/src/custom/generator.spec.ts

@@ -0,0 +1,75 @@
+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()
+  })
+})