@nestledjs/api 0.0.1

package/src/custom/generator.ts

@@ -0,0 +1,239 @@
+import { formatFiles, installPackagesTask, Tree } from '@nx/devkit'
+import { getDMMF } from '@prisma/internals'
+import { addToModules, apiLibraryGenerator, getPrismaSchemaPath, readPrismaSchema } from '@nestledjs/utils'
+import { GenerateCustomGeneratorSchema } from './schema'
+import { execSync } from 'child_process'
+import { getNpmScope } from '@nx/js/src/utils/package-json/get-npm-scope'
+import pluralize from 'pluralize'
+import { join } from 'path'
+
+// Group all dependencies into a single object
+const defaultDependencies = {
+  formatFiles,
+  installPackagesTask,
+  getDMMF,
+  addToModules,
+  apiLibraryGenerator,
+  getPrismaSchemaPath,
+  readPrismaSchema,
+  execSync,
+  getNpmScope,
+  pluralize,
+  join,
+}
+export type CustomGeneratorDependencies = typeof defaultDependencies
+
+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
+}
+
+async function getAllPrismaModels(tree: Tree, dependencies: CustomGeneratorDependencies): 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)
+
+      // Create a properly typed fields array
+      const fields = model.fields.map((field) => ({
+        name: field.name,
+        type: field.type,
+        isId: field.isId,
+        isRequired: field.isRequired,
+        isList: field.isList,
+        isUnique: field.isUnique,
+        isReadOnly: field.isReadOnly,
+        isGenerated: field.isGenerated,
+        isUpdatedAt: field.isUpdatedAt,
+        documentation: field.documentation,
+        // Include any other properties that might be needed
+        ...field,
+      }))
+
+      // Create and return the model
+      const modelData: ModelType = {
+        name: model.name,
+        pluralName: dependencies.pluralize(model.name),
+        fields,
+        primaryField: model.fields.find((f) => !f.isId && f.type === 'String')?.name || 'name',
+        modelName: model.name,
+        modelPropertyName: singularPropertyName,
+        pluralModelName: dependencies.pluralize(model.name),
+        pluralModelPropertyName: pluralPropertyName,
+      }
+
+      return modelData
+    })
+  } catch (error) {
+    console.error('Error parsing Prisma schema:', error)
+    return []
+  }
+}
+
+async function ensureDirExists(tree: Tree, path: string) {
+  if (!tree.exists(path)) {
+    // Only create the directory, do not write .gitkeep
+    // Directory will be created when a file is written into it
+  }
+}
+
+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()
+}
+
+async function generateCustomFiles(
+  tree: Tree,
+  customLibraryRoot: string,
+  models: ModelType[],
+  npmScope: string,
+  dependencies: CustomGeneratorDependencies,
+) {
+  const defaultDir = dependencies.join(customLibraryRoot, 'src/lib/default')
+  const pluginsDir = dependencies.join(customLibraryRoot, 'src/lib/plugins')
+  await ensureDirExists(tree, defaultDir)
+  await ensureDirExists(tree, pluginsDir)
+  // Only write .gitkeep in pluginsDir
+  tree.write(dependencies.join(pluginsDir, '.gitkeep'), '')
+
+  for (const model of models) {
+    const kebabModel = toKebabCase(model.modelName)
+    const modelFolder = dependencies.join(defaultDir, kebabModel)
+    if (tree.exists(modelFolder)) {
+      // Skip if model folder already exists
+      continue
+    }
+    await ensureDirExists(tree, modelFolder)
+
+    // Generate service.ts
+    const serviceContent = `import { Injectable } from '@nestjs/common'
+
+@Injectable()
+export class ${model.modelName}Service {
+  // Empty for now; will override or extend later if needed
+}
+`
+    tree.write(dependencies.join(modelFolder, `${kebabModel}.service.ts`), serviceContent)
+
+    // Generate resolver.ts
+    const resolverContent = `
+import { ApiCrudDataAccessService } from '${npmScope}/api/generated-crud/data-access'
+import { Generated${model.modelName}Resolver } from '${npmScope}/api/generated-crud/feature'
+import { Injectable } from '@nestjs/common'
+import { Resolver } from '@nestjs/graphql'
+import { ${model.modelName} } from '${npmScope}/api/core/models'
+
+@Resolver(() => ${model.modelName})
+@Injectable()
+export class ${model.modelName}Resolver extends Generated${model.modelName}Resolver {
+  constructor(
+    // private readonly customService: ${model.modelName}Service,
+    generatedService: ApiCrudDataAccessService,
+  ) {
+    super(generatedService)
+  }
+}
+`
+    tree.write(dependencies.join(modelFolder, `${kebabModel}.resolver.ts`), resolverContent)
+
+    // Generate module.ts
+    const moduleContent = `import { Module } from '@nestjs/common'
+import { ${model.modelName}Service } from './${kebabModel}.service'
+import { ${model.modelName}Resolver } from './${kebabModel}.resolver'
+import { ApiCrudDataAccessModule } from '${npmScope}/api/generated-crud/data-access'
+
+@Module({
+  imports: [ApiCrudDataAccessModule],
+  providers: [${model.modelName}Service, ${model.modelName}Resolver],
+  exports: [${model.modelName}Service, ${model.modelName}Resolver],
+})
+export class ${model.modelName}Module {}
+`
+    tree.write(dependencies.join(modelFolder, `${kebabModel}.module.ts`), moduleContent)
+
+    // Add to defaultModules in app.module.ts__tmpl__
+    dependencies.addToModules({
+      tree,
+      modulePath: 'apps/api/src/app.module.ts',
+      moduleArrayName: 'defaultModules',
+      moduleToAdd: `${model.modelName}Module`,
+      importPath: `${npmScope}/api/custom`,
+    })
+  }
+
+  // Update index.ts to export all model modules
+  const modelFolders = models.map((m) => toKebabCase(m.modelName))
+  const indexContent = modelFolders.map((m) => `export * from './lib/default/${m}/${m}.module'`).join('\n')
+  tree.write(dependencies.join(customLibraryRoot, 'src/index.ts'), indexContent)
+}
+
+export async function customGeneratorLogic(
+  tree: Tree,
+  schema: GenerateCustomGeneratorSchema,
+  dependencies: CustomGeneratorDependencies = defaultDependencies,
+) {
+  try {
+    const name = schema.name || 'custom'
+    const customLibraryRoot = schema.directory ? `libs/api/${schema.directory}/${name}` : `libs/api/${name}`
+    const projectName = schema.directory ? `api-${schema.directory.replace(/\//g, '-')}-${name}` : `api-${name}`
+
+    // Overwrite logic
+    if (schema.overwrite && tree.exists(customLibraryRoot)) {
+      try {
+        dependencies.execSync(`nx g @nx/workspace:remove ${projectName} --forceRemove`, {
+          stdio: 'inherit',
+          cwd: tree.root,
+        })
+      } catch (error) {
+        console.warn(`Failed to remove existing library ${projectName}:`, error)
+      }
+    }
+
+    // Use the shared apiLibraryGenerator
+    await dependencies.apiLibraryGenerator(tree, { name }, '', undefined, false)
+
+    await ensureDirExists(tree, dependencies.join(customLibraryRoot, 'src/lib/default'))
+    await ensureDirExists(tree, dependencies.join(customLibraryRoot, 'src/lib/plugins'))
+
+    // Get all Prisma models
+    const models = await getAllPrismaModels(tree, dependencies)
+    if (models.length === 0) {
+      console.error('No Prisma models found')
+      return
+    }
+
+    // Generate custom files per model
+    const npmScope = `@${dependencies.getNpmScope(tree)}`
+    await generateCustomFiles(tree, customLibraryRoot, models, npmScope, dependencies)
+
+    // Format files
+    await dependencies.formatFiles(tree)
+
+    return () => {
+      dependencies.installPackagesTask(tree)
+    }
+  } catch (error) {
+    console.error('Error in Custom generator:', error)
+    throw error
+  }
+}
+
+export default async function (tree: Tree, schema: GenerateCustomGeneratorSchema) {
+  return customGeneratorLogic(tree, schema)
+}

package/src/custom/schema.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "../../node_modules/@nx/devkit/schema.d.json",
+  "extends": "../../node_modules/@nx/devkit/generators.json",
+  "properties": {
+    "name": {
+      "description": "Name of the custom library to generate",
+      "type": "string",
+      "default": "custom"
+    },
+    "directory": {
+      "description": "Optional directory to place the library",
+      "type": "string"
+    },
+    "overwrite": {
+      "description": "Whether to overwrite existing files",
+      "type": "boolean",
+      "default": false
+    }
+  },
+  "required": []
+}

package/src/custom/schema.ts

@@ -0,0 +1,5 @@
+export interface GenerateCustomGeneratorSchema {
+  name?: string;
+  directory?: string;
+  overwrite?: boolean;
+}

package/src/extended/generator.spec.ts

@@ -0,0 +1,95 @@
+import { Tree } from '@nx/devkit'
+import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing'
+import { vi, describe, it, expect, beforeEach } from 'vitest'
+import { getDMMF } from '@prisma/internals'
+import { getNpmScope } from '@nx/js/src/utils/package-json/get-npm-scope'
+import generator from './generator'
+import { apiLibraryGenerator, getPrismaSchemaPath, readPrismaSchema } from '@nestledjs/utils'
+
+// Mock dependencies
+vi.mock('@prisma/internals')
+vi.mock('@nestledjs/utils', () => {
+  return {
+    apiLibraryGenerator: vi.fn().mockResolvedValue(undefined),
+    getPrismaSchemaPath: vi.fn(),
+    readPrismaSchema: vi.fn(),
+  }
+})
+vi.mock('@nx/js/src/utils/package-json/get-npm-scope')
+
+describe('extended-generator', () => {
+  let tree: Tree
+
+  beforeEach(async () => {
+    tree = createTreeWithEmptyWorkspace()
+    vi.clearAllMocks()
+
+    vi.mocked(getNpmScope).mockReturnValue('test-scope')
+    vi.mocked(getPrismaSchemaPath).mockReturnValue('prisma/schema.prisma')
+    vi.mocked(readPrismaSchema).mockReturnValue(`
+      model User {
+        id Int @id @default(autoincrement())
+        name String
+      }
+      model Post {
+        id Int @id @default(autoincrement())
+        title String
+      }
+    `)
+    vi.mocked(getDMMF).mockResolvedValue({
+      datamodel: {
+        models: [
+          {
+            name: 'User',
+            fields: [
+              { name: 'id', type: 'Int', isId: true },
+              { name: 'name', type: 'String' },
+            ],
+          },
+          {
+            name: 'Post',
+            fields: [
+              { name: 'id', type: 'Int', isId: true },
+              { name: 'title', type: 'String' },
+            ],
+          },
+        ],
+      },
+    } as any)
+  })
+
+  it('should generate a library for each model with expected files', async () => {
+    await generator(tree, { overwrite: true })
+    // User library
+    expect(apiLibraryGenerator).toHaveBeenCalledWith(
+      tree,
+      { name: 'extended-user', overwrite: true },
+      '',
+      undefined,
+      false,
+    )
+    expect(tree.exists('libs/api/extended/user/src/lib/user.service.ts')).toBe(true)
+    expect(tree.exists('libs/api/extended/user/src/lib/user.resolver.ts')).toBe(true)
+    expect(tree.exists('libs/api/extended/user/src/lib/user.module.ts')).toBe(true)
+    expect(tree.exists('libs/api/extended/user/src/index.ts')).toBe(true)
+    // Post library
+    expect(apiLibraryGenerator).toHaveBeenCalledWith(
+      tree,
+      { name: 'extended-post', overwrite: true },
+      '',
+      undefined,
+      false,
+    )
+    expect(tree.exists('libs/api/extended/post/src/lib/post.service.ts')).toBe(true)
+    expect(tree.exists('libs/api/extended/post/src/lib/post.resolver.ts')).toBe(true)
+    expect(tree.exists('libs/api/extended/post/src/lib/post.module.ts')).toBe(true)
+    expect(tree.exists('libs/api/extended/post/src/index.ts')).toBe(true)
+  })
+
+  it('should not generate files if no models are found', async () => {
+    vi.mocked(getDMMF).mockResolvedValue({ datamodel: { models: [] } } as any)
+    await generator(tree, { overwrite: true })
+    // No libraries should be created
+    expect(apiLibraryGenerator).not.toHaveBeenCalled()
+  })
+})

package/src/extended/generator.ts

@@ -0,0 +1,161 @@
+import { formatFiles, installPackagesTask, Tree } from '@nx/devkit'
+import { getDMMF } from '@prisma/internals'
+import { apiLibraryGenerator, getPrismaSchemaPath, readPrismaSchema } from '@nestledjs/utils'
+import { GenerateExtendedGeneratorSchema } from './schema'
+import { getNpmScope } from '@nx/js/src/utils/package-json/get-npm-scope'
+import pluralize from 'pluralize'
+import { join } from 'path'
+
+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
+}
+
+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()
+}
+
+async function getAllPrismaModels(tree: Tree): Promise<ModelType[]> {
+  const prismaPath = getPrismaSchemaPath(tree)
+  const prismaSchema = readPrismaSchema(tree, prismaPath)
+  if (!prismaSchema) {
+    console.error(`No Prisma schema found at ${prismaPath}`)
+    return []
+  }
+
+  try {
+    const dmmf = await getDMMF({ datamodel: prismaSchema })
+    return dmmf.datamodel.models.map((model) => {
+      const singularPropertyName = model.name.charAt(0).toLowerCase() + model.name.slice(1)
+      const pluralPropertyName = pluralize(singularPropertyName)
+      const fields = model.fields.map((field) => ({
+        name: field.name,
+        type: field.type,
+        isId: field.isId,
+        isRequired: field.isRequired,
+        isList: field.isList,
+        isUnique: field.isUnique,
+        isReadOnly: field.isReadOnly,
+        isGenerated: field.isGenerated,
+        isUpdatedAt: field.isUpdatedAt,
+        documentation: field.documentation,
+        ...field,
+      }))
+      return {
+        name: model.name,
+        pluralName: pluralize(model.name),
+        fields,
+        primaryField: model.fields.find((f) => !f.isId && f.type === 'String')?.name || 'name',
+        modelName: model.name,
+        modelPropertyName: singularPropertyName,
+        pluralModelName: pluralize(model.name),
+        pluralModelPropertyName: pluralPropertyName,
+      }
+    })
+  } catch (error) {
+    console.error('Error parsing Prisma schema:', error)
+    return []
+  }
+}
+
+async function generateModelLibrary(tree: Tree, model: ModelType, npmScope: string, overwrite: boolean) {
+  const kebabModel = toKebabCase(model.modelName)
+  const libName = kebabModel
+  const libRoot = `libs/api/extended/${libName}`
+
+  // Create the Nx library for this model
+  await apiLibraryGenerator(tree, { name: `extended-${libName}`, overwrite }, '', undefined, false)
+
+  // Generate service.ts
+  const serviceContent = `import { Injectable } from '@nestjs/common'
+
+@Injectable()
+export class ${model.modelName}Service {
+  // Empty for now; will override or extend later if needed
+}
+`
+  tree.write(join(libRoot, 'src/lib', `${kebabModel}.service.ts`), serviceContent)
+
+  // Generate resolver.ts
+  const resolverContent = `import { ${model.modelName}Service } from './${kebabModel}.service'
+import { ApiCrudDataAccessService } from '${npmScope}/api/generated-crud/data-access'
+import { Generated${model.modelName}Resolver } from '${npmScope}/api/generated-crud/feature'
+import { Injectable } from '@nestjs/common'
+import { Resolver } from '@nestjs/graphql'
+import { ${model.modelName} } from '${npmScope}/api/core/models'
+
+@Resolver(() => ${model.modelName})
+@Injectable()
+export class ${model.modelName}Resolver extends Generated${model.modelName}Resolver {
+  constructor(
+    private readonly customService: ${model.modelName}Service,
+    private readonly generatedService: ApiCrudDataAccessService,
+  ) {
+    super(generatedService)
+  }
+}
+`
+  tree.write(join(libRoot, 'src/lib', `${kebabModel}.resolver.ts`), resolverContent)
+
+  // Generate module.ts
+  const moduleContent = `import { Module } from '@nestjs/common'
+import { ${model.modelName}Service } from './${kebabModel}.service'
+import { ${model.modelName}Resolver } from './${kebabModel}.resolver'
+
+@Module({
+  providers: [${model.modelName}Service, ${model.modelName}Resolver],
+  exports: [${model.modelName}Service, ${model.modelName}Resolver],
+})
+export class ${model.modelName}Module {}
+`
+  tree.write(join(libRoot, 'src/lib', `${kebabModel}.module.ts`), moduleContent)
+
+  // Update index.ts to export the module
+  const indexContent = `export * from './lib/${kebabModel}.module'`
+  tree.write(join(libRoot, 'src/index.ts'), indexContent)
+
+  // Optionally, add to app.module.ts or other registration logic here
+  // addToModules({ ... })
+}
+
+export default async function (tree: Tree, schema: GenerateExtendedGeneratorSchema) {
+  try {
+    // Ensure the extended folder exists (not an Nx project)
+    const extendedRoot = 'libs/api/extended'
+    if (!tree.exists(extendedRoot)) {
+      tree.write(join(extendedRoot, '.gitkeep'), '')
+    }
+
+    // Get all Prisma models
+    const models = await getAllPrismaModels(tree)
+    if (models.length === 0) {
+      console.error('No Prisma models found')
+      return
+    }
+
+    const npmScope = `@${getNpmScope(tree)}`
+    const overwrite = !!schema.overwrite
+
+    // For each model, generate a library and custom files
+    for (const model of models) {
+      await generateModelLibrary(tree, model, npmScope, overwrite)
+    }
+
+    await formatFiles(tree)
+    return () => {
+      installPackagesTask(tree)
+    }
+  } catch (error) {
+    console.error('Error in Extended generator:', error)
+    throw error
+  }
+}

package/src/extended/index.ts

@@ -0,0 +1 @@
+export { default } from './generator' 

package/src/extended/schema.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "../../node_modules/@nx/devkit/schema.d.json",
+  "extends": "../../node_modules/@nx/devkit/generators.json",
+  "properties": {
+    "overwrite": {
+      "description": "Whether to overwrite existing files",
+      "type": "boolean",
+      "default": false
+    }
+  },
+  "required": []
+} 

package/src/extended/schema.ts

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

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

@@ -0,0 +1,3 @@
+export * from './lib/api-crud-data-access.module'
+export * from './lib/api-crud-data-access.service'
+export * from './lib/dto'

package/src/generate-crud/files/data-access/src/lib/api-crud-data-access.module.ts__tmpl__

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common'
+
+import { ApiCrudDataAccessService } from './api-crud-data-access.service'
+import { ApiCoreDataAccessModule } from '<%= npmScope %>/api/core/data-access'
+
+@Module({
+  imports: [ApiCoreDataAccessModule],
+  providers: [ApiCrudDataAccessService],
+  exports: [ApiCrudDataAccessService],
+})
+export class ApiCrudDataAccessModule {}

package/src/generate-crud/files/data-access/src/lib/api-crud-data-access.service.ts__tmpl__

@@ -0,0 +1,72 @@
+import { Injectable } from '@nestjs/common'
+import { ApiCoreDataAccessService } from '<%= npmScope %>/api/core/data-access'
+import { PrismaSelect } from '@paljs/plugins'
+import type { GraphQLResolveInfo } from 'graphql'
+import * as dto from './dto'
+
+<% models.forEach((model, idx) => { %>
+<% if (!model.modelName || !model.pluralModelName) { throw new Error('EJS template error: modelName or pluralModelName missing for model at index ' + idx + ': ' + JSON.stringify(model)); } %>
+<% }) %>
+
+@Injectable()
+export class ApiCrudDataAccessService {
+  constructor(private readonly data: ApiCoreDataAccessService) {}
+
+<% for (const model of models) { %>
+  async create<%= model.modelName.charAt(0).toUpperCase() + model.modelName.slice(1) %>(info: GraphQLResolveInfo, input: dto.Create<%= model.modelName %>Input) {
+    const select = new PrismaSelect(info).value
+    return this.data['<%= model.modelPropertyName %>'].create({
+      data: input,
+      ...select,
+    });
+  }
+
+  async <%= (model.pluralModelName === model.modelName ? model.pluralModelName + 'List' : model.pluralModelName).charAt(0).toLowerCase() + (model.pluralModelName === model.modelName ? model.pluralModelName + 'List' : model.pluralModelName).slice(1) %>(info: GraphQLResolveInfo, input?: dto.List<%= model.modelName %>Input) {
+    const select = new PrismaSelect(info).value
+    return this.data['<%= model.modelPropertyName %>'].findMany({
+      ...this.data.filter(input),
+      ...select,
+    });
+  }
+
+  async <%= (model.pluralModelName === model.modelName ? model.pluralModelName + 'List' : model.pluralModelName).charAt(0).toLowerCase() + (model.pluralModelName === model.modelName ? model.pluralModelName + 'List' : model.pluralModelName).slice(1) %>Count(input?: dto.List<%= model.modelName %>Input) {
+    const total = await this.data['<%= model.modelPropertyName %>'].count()
+    const count = await this.data['<%= model.modelPropertyName %>'].count({
+      ...this.data.filter(input)
+    });
+    const take = input?.take || 10
+    const skip = input?.skip || 0
+    const page = Math.floor(skip / take)
+     return {
+      take,
+      skip,
+      page,
+      count,
+      total,
+    }
+  }
+
+  async <%= model.modelName.charAt(0).toLowerCase() + model.modelName.slice(1) %>(info: GraphQLResolveInfo, id: string) {
+    const select = new PrismaSelect(info).value
+    return this.data['<%= model.modelPropertyName %>'].findUnique({
+      where: { id },
+      ...select,
+    });
+  }
+
+  async update<%= model.modelName.charAt(0).toUpperCase() + model.modelName.slice(1) %>(info: GraphQLResolveInfo, id: string, input: dto.Update<%= model.modelName %>Input) {
+    const select = new PrismaSelect(info).value
+    return this.data['<%= model.modelPropertyName %>'].update({
+      where: { id },
+      data: input,
+      ...select,
+    });
+  }
+
+  async delete<%= model.modelName.charAt(0).toUpperCase() + model.modelName.slice(1) %>(id: string) {
+    return this.data['<%= model.modelPropertyName %>'].delete({
+      where: { id }
+    });
+  }
+<% } %>
+}