⚡ IMPROVE: ctx generation

.changeset/ninety-birds-protect.md

@@ -0,0 +1,5 @@
+---
+'@kitql/all-in': patch
+---
+
+ctx generation are back

packages/all-in/src/lib/cjs.cjs

@@ -15,6 +15,7 @@ function kitQLCodegen(projectLocation, scalars) {
         config: {
           contextType: '$graphql/kitQLServer#IKitQLContext',
           scalars,
+          useTypeImports: true,
         },
       },
     },

packages/all-in/src/lib/vite/actionContexts.ts

@@ -0,0 +1,30 @@
+import { join } from 'path'
+
+import { createFolderIfNotExists } from './fileFolder.js'
+import { toPascalCase } from './formatString.js'
+import { write } from './readWrite.js'
+
+export function actionContext(ctxModules: { ctxName: string; moduleName: string }[], outputFolder: string) {
+  const dataCtxModules = []
+
+  ctxModules.forEach(ctx => {
+    dataCtxModules.push(
+      `import { getCtx${toPascalCase(ctx.ctxName)} } from '../../modules/${ctx.moduleName}/providers/_ctx${toPascalCase(
+        ctx.ctxName
+      )}';`
+    )
+  })
+
+  dataCtxModules.push(``)
+  dataCtxModules.push(`export function getCtxModules(prisma: any) {`)
+  dataCtxModules.push(`	return {`)
+  ctxModules.forEach(ctx => {
+    dataCtxModules.push(`		...getCtx${toPascalCase(ctx.ctxName)}(prisma),`)
+  })
+  dataCtxModules.push(`	};`)
+  dataCtxModules.push(`}`)
+
+  createFolderIfNotExists(join(outputFolder))
+
+  write(join(outputFolder, '_ctxModules.ts'), dataCtxModules)
+}

packages/all-in/src/lib/vite/actionModuleContext.ts

@@ -0,0 +1,71 @@
+import { basename, extname, join } from 'path'
+
+import { createFolderIfNotExists } from './fileFolder.js'
+import { toPascalCase } from './formatString.js'
+import { write } from './readWrite.js'
+
+// dlIchttsGetByIds
+// dl{EntityName}Get{Function}s => ctx{EntityName}_Dl_{Function}
+// ctxIchtts_Dl_ById
+export function actionModuleContext(
+  dataloadersModule: { moduleName: string; providerFile: string }[], // ["dlIchttsGetByIds"]
+  moduleFolder: string, // src/lib/modules
+  moduleOutputFolder: string, //$kitql
+  importBaseTypesFrom: string,
+  withDbProvider: boolean
+) {
+  const dataCtxModules = []
+  const moduleName = basename(moduleFolder, extname(moduleFolder))
+
+  const moduleNamePascalCase = toPascalCase(moduleName)
+  const functionsName: string[] = []
+  dataloadersModule.forEach(dataloader => {
+    const functionName = dataloader.providerFile
+      .substring(moduleName.length + 2 + 3) // + 2 => dl & + 3 => Get
+      .replace(`s.ts`, '')
+    functionsName.push(functionName)
+  })
+
+  if (withDbProvider) {
+    dataCtxModules.push(`import { load_DataLoader } from '../../../../lib/graphql/helpers/dataLoaderHelper';`)
+    dataCtxModules.push(`import type { IKitQLContext } from '../../../../lib/graphql/kitQLServer';`)
+    if (functionsName.length > 0) {
+      dataCtxModules.push(`import type { ${moduleNamePascalCase} } from '${importBaseTypesFrom}';`)
+    }
+    dataCtxModules.push(`import { Db${moduleNamePascalCase} } from '../providers/Db${moduleNamePascalCase}';`)
+    functionsName.forEach(functionName => {
+      dataCtxModules.push(
+        `import { dl${moduleNamePascalCase}Get${functionName}s } from '../providers/dl${moduleNamePascalCase}Get${functionName}s';`
+      )
+    })
+
+    dataCtxModules.push(``)
+    dataCtxModules.push(`export function ctx${moduleNamePascalCase}(ctx: IKitQLContext) {`)
+    dataCtxModules.push(` // @ts-ignore`)
+    dataCtxModules.push(` return ctx.injector.get(Db${moduleNamePascalCase}) as Db${moduleNamePascalCase};`)
+    dataCtxModules.push(`}`)
+    dataCtxModules.push(``)
+  } else {
+    dataCtxModules.push(`// No DbProvider found`)
+    dataCtxModules.push(`export {}`)
+  }
+
+  functionsName.forEach(functionName => {
+    dataCtxModules.push(
+      `export async function ctx${moduleNamePascalCase}_Dl_${functionName}(ctx: IKitQLContext, id: string | number) {`
+    )
+    dataCtxModules.push(` // @ts-ignore`)
+    dataCtxModules.push(
+      `	return load_DataLoader<${moduleNamePascalCase}>(ctx.injector, dl${moduleNamePascalCase}Get${functionName}s.provide, id) as ${moduleNamePascalCase};`
+    )
+    dataCtxModules.push(`}`)
+  })
+
+  dataCtxModules.push(``)
+
+  createFolderIfNotExists(join(moduleFolder, moduleOutputFolder))
+
+  write(join(moduleFolder, moduleOutputFolder, 'ctx.ts'), dataCtxModules)
+
+  return functionsName.length + (withDbProvider ? 1 : 0)
+}

packages/all-in/src/lib/vite/generate.ts

@@ -1,19 +1,22 @@
 import { Log, logGreen, logRed } from '@kitql/helper'
-import { basename, extname } from 'path'
+import { basename, extname, join } from 'path'
 
-import { type KitQLVite } from './KitQLVite.js'
+import type { KitQLVite } from './KitQLVite.js'
+import { actionContext } from './actionContexts.js'
 import { actionEnum } from './actionEnum.js'
+import { actionModuleContext } from './actionModuleContext.js'
 import { actionModules } from './actionModules.js'
 import { actionResolvers } from './actionResolvers.js'
 import { actionTypeDefs } from './actionTypeDefs.js'
-import { getDirectories, getFullPath } from './fileFolder.js'
+import { getDirectories, getFiles, getFullPath } from './fileFolder.js'
+import { toPascalCase } from './formatString.js'
 import { getPrismaEnum } from './prismaHelper.js'
 import { readLines } from './readWrite.js'
 
 export function generate(config?: KitQLVite) {
   const log = new Log('KitQL')
 
-  // const providersFolder = 'providers' as const
+  const providersFolder = 'providers' as const
 
   const { outputFolder, moduleOutputFolder, importBaseTypesFrom, modules } = {
     outputFolder: 'src/lib/graphql/$kitql',
@@ -35,6 +38,7 @@ export function generate(config?: KitQLVite) {
     modules: 0,
     typedefs: 0,
     resolvers: 0,
+    contexts: 0,
   }
 
   // Enums
@@ -50,6 +54,7 @@ export function generate(config?: KitQLVite) {
       const enums = getPrismaEnum(readLines(prismaFilePath))
       const enumsKeys = actionEnum(enumsModuleFolder, moduleOutputFolder, importBaseTypesFrom, enums)
       meta.enums = enumsKeys.length
+      // log.info(`${logGreen('✔')} ${logGreen('Enums')} created [${enumsKeys.map(c => logGreen(c)).join(',')}]`)
     } else {
       log.error(`${'❌'} file ${logRed(prismaFilePath)} not found!`)
       throw new Error(`file ${prismaFilePath} not found!`)
@@ -67,6 +72,9 @@ export function generate(config?: KitQLVite) {
   if (mergeContexts) {
     mergeModuleAction.push('Contexts')
   }
+  if (mergeModuleAction.length > 0) {
+    // log.info(`${logGreen('⏳')} merging ${mergeModuleAction.map(c => logGreen(c)).join(' and ')} in modules`)
+  }
 
   const contexts: { moduleName: string; ctxName: string }[] = []
   const modulesObj: { name: string; directory: string }[] = []
@@ -77,6 +85,7 @@ export function generate(config?: KitQLVite) {
 
       let typedefsFilesLength = 0
       let resolversFilesLength = 0
+      let contextsFilesLength = 0
 
       // TypeDefs
       if (mergeModuleTypedefs) {
@@ -89,48 +98,118 @@ export function generate(config?: KitQLVite) {
       }
 
       // Contexts
-      // if (mergeContexts) {
-      //   const dataloadersModule: { moduleName: string; providerFile: string }[] = []
-      //   const providersFiles = getFiles(join(directory, providersFolder))
-      //   let withDbProvider = false
-      //   providersFiles.forEach(providerFile => {
-      //     if (providerFile.startsWith(`dl${toPascalCase(moduleName)}`)) {
-      //       dataloadersModule.push({ moduleName, providerFile })
-      //     }
-      //     if (providerFile.startsWith(`Db${toPascalCase(moduleName)}`)) {
-      //       withDbProvider = true
-      //     }
-      //   })
-
-      //   providersFiles.forEach(providerFile => {
-      //     if (providerFile.startsWith('_ctx')) {
-      //       const ctxName = providerFile.replace('_ctx', '').replace('.ts', '')
-      //       contexts.push({ moduleName, ctxName })
-      //     }
-      //   })
-      // }
+      if (mergeContexts) {
+        const dataloadersModule: { moduleName: string; providerFile: string }[] = []
+        const providersFiles = getFiles(join(directory, providersFolder))
+        let withDbProvider = false
+        providersFiles.forEach(providerFile => {
+          if (providerFile.startsWith(`dl${toPascalCase(moduleName)}`)) {
+            dataloadersModule.push({ moduleName, providerFile })
+          }
+          if (providerFile.startsWith(`Db${toPascalCase(moduleName)}`)) {
+            withDbProvider = true
+          }
+        })
+        contextsFilesLength = actionModuleContext(
+          dataloadersModule,
+          directory,
+          moduleOutputFolder,
+          importBaseTypesFrom,
+          withDbProvider
+        )
+
+        // log.info(`${logGreen('⏳')} merging ${logGreen('Contexts')}`)
+        providersFiles.forEach(providerFile => {
+          if (providerFile.startsWith('_ctx')) {
+            const ctxName = providerFile.replace('_ctx', '').replace('.ts', '')
+            contexts.push({ moduleName, ctxName })
+          }
+        })
+      }
 
       if (mergeModuleAction.length > 0) {
         meta.typedefs += typedefsFilesLength
         meta.resolvers += resolversFilesLength
+        meta.contexts += contextsFilesLength
+        // log.info(
+        //   `${logGreen('✔')} merged - ${logGreen(pad(typedefsFilesLength, 2))} Typedefs | ${logGreen(
+        //     pad(resolversFilesLength, 2)
+        //   )} Resolvers | ${logGreen(pad(contextsFilesLength, 2))} Contexts for [${logGreen(name)}]`
+        // )
       }
 
       modulesObj.push({ directory, name: moduleName })
     })
   })
 
+  // mergeContexts
+  if (mergeContexts) {
+    // log.info(`${logGreen('⏳')} merging ${logGreen('Contexts')}`)
+    actionContext(contexts, outputFolder)
+
+    // log.info(
+    //   `${logGreen('✔')} merged ${logGreen(pad(contexts.length, 2))} contexts [${contexts
+    //     .map(c => logGreen(c.moduleName + '#' + c.ctxName))
+    //     .join(',')}]`
+    // )
+  }
+
+  // "if" or collapsing purpose
+  // if (true) {
+  // mergeModuleContexts
+  // if (config.actions.mergeContexts) {
+  // 	log.info(`${logGreen('⏳')} merging modules ${logGreen('Contexts')}`);
+  // 	const providersFolder = 'providers';
+  // 	moduleNames.forEach(moduleName => {
+  // 		let dataloadersModule = [];
+  // 		const providersFiles = getFiles(
+  // 			join(config.config.modulesFolder, moduleName, providersFolder)
+  // 		);
+  // 		providersFiles.forEach(providerFile => {
+  // 			if (providerFile.startsWith(`dl${toPascalCase(moduleName)}`)) {
+  // 				dataloadersModule.push({ moduleName, providerFile });
+  // 			}
+  // 		});
+  // 		actionModuleContext(
+  // 			dataloadersModule,
+  // 			config.config.modulesFolder,
+  // 			moduleName,
+  // 			config.config.moduleOutputFolder
+  // 		);
+  // 		log.info(
+  // 			`${logGreen('✔')} merged ${logGreen(
+  // 				pad(dataloadersModule.length, 2)
+  // 			)} contexts [${dataloadersModule
+  // 				.map(c => logGreen(c.moduleName + '#' + c.ctxName))
+  // 				.join(',')}]`
+  // 		);
+  // 	});
+  // }
+  //
+  // }
+
   // mergeModules
   if (mergeModules) {
+    // log.info(`${logGreen('⏳')} merging ${logGreen('Modules')}`)
     actionModules(modulesObj, outputFolder)
     meta.modules = modulesObj.length
+    // log.info(
+    //   `${logGreen('✔')} merged ${logGreen(pad(modules.length, 2))} modules [${modules
+    //     .map(c => logGreen(c))
+    //     .join(',')}]`
+    // )
   }
 
+  //
+
   // Done
+  // log.info(`${logGreen('✔')} finished ${logGreen('successfully')}`)
   log.info(
     `${logGreen('✔')} success ` +
       `[${logGreen('' + meta.modules)} modules, ` +
       `${logGreen('' + meta.enums)} enums, ` +
       `${logGreen('' + meta.typedefs)} typedefs, ` +
-      `${logGreen('' + meta.resolvers)} resolvers]`
+      `${logGreen('' + meta.resolvers)} resolvers, ` +
+      `${logGreen('' + meta.contexts)} contexts]`
   )
 }