@postxl/generator 0.45.0 → 0.47.0

package/README.md

@@ -1,3 +1,22 @@
 # PXL Generator
 
-A utility package that lets you move quickly and generate basic components of your app easily.
+A utility package that lets you move quickly and generate basic components of your app easily.
+
+#### Linking Generator to Template
+
+To use the latest version of the generator link the local dependency using [`pnpm link`](https://pnpm.io/cli/link) command.
+
+```sh
+# /
+pnpm build
+
+# /packages/manager/template/
+pnpm link ../../generator/
+
+# /
+pnpm prisma generate
+```
+
+> If you've correctly linked the generator, you should see a message when running `pnpm i`.
+
+![pnpm link](./media/link.png)

package/dist/generator.js

@@ -93,7 +93,7 @@ const CONFIG_SCHEMA = zod_1.z
     pathToTypes: zod_1.z.string().optional(),
     trpcRoutesFolder: zod_1.z.string().optional(),
     reactFolderOutput: zod_1.z.string().optional(),
-    migrationsFolder: zod_1.z.string().optional(),
+    prismaMigrationsFolder: zod_1.z.string().optional(),
     randomSeed: zod_1.z
         .string()
         .optional()
@@ -106,31 +106,21 @@ const CONFIG_SCHEMA = zod_1.z
     .transform((s) => {
     return {
         paths: {
-            dataLibPath: (0, types_1.toPath)(s.pathToDataLib || 'repos'),
+            dataLibPath: (0, types_1.toPath)(s.pathToDataLib || './backend/libs/data/src/'),
             cypressPath: (0, types_1.toPath)(s.pathToCypress || './e2e/cypress/'),
-            e2eLibPath: (0, types_1.toPath)(s.pathToE2ELib || './e2e/src/'),
-            importExportPath: (0, types_1.toPath)(s.pathToImportExport || 'import-export'),
-            actionsPath: (0, types_1.toPath)(s.pathToActions || 'actions'),
-            businessLogicPath: (0, types_1.toPath)(s.pathToBusinessLogic || 'business-logic'),
-            migrationsFolderPath: (0, types_1.toPath)(s.migrationsFolder || 'migrations'),
-            modelTypeDefinitionsPath: (0, types_1.toPath)(s.pathToTypes || 'types'),
-            reactFolderPath: (0, types_1.toPath)(s.reactFolderOutput || 'react'),
-            seedDataPath: (0, types_1.toPath)(s.pathToSeedData || 'seed-data'),
-            seedLibPath: (0, types_1.toPath)(s.pathToSeedLib || 'seed'),
-            trpcRoutesFolderPath: (0, types_1.toPath)(s.trpcRoutesFolder || 'trpc'),
+            e2eLibPath: (0, types_1.toPath)(s.pathToE2ELib || './backend/libs/e2e/src/'),
+            importExportPath: (0, types_1.toPath)(s.pathToImportExport || './backend/libs/import-export/src/'),
+            actionsPath: (0, types_1.toPath)(s.pathToActions || './backend/libs/actions/src/'),
+            businessLogicPath: (0, types_1.toPath)(s.pathToBusinessLogic || './backend/libs/business-logic/src/'),
+            prismaMigrationsFolderPath: (0, types_1.toPath)(s.prismaMigrationsFolder || './migrations'),
+            modelTypeDefinitionsPath: (0, types_1.toPath)(s.pathToTypes || './backend/libs/types/src/'),
+            reactFolderPath: (0, types_1.toPath)(s.reactFolderOutput || './web/src/components/'),
+            seedDataPath: (0, types_1.toPath)(s.pathToSeedData || './backend/seed-data/src/'),
+            seedLibPath: (0, types_1.toPath)(s.pathToSeedLib || './backend/libs/seed/src/'),
+            trpcRoutesFolderPath: (0, types_1.toPath)(s.trpcRoutesFolder || './backend/libs/trpc/src/routes/'),
         },
         randomSeed: s.randomSeed,
         force: s.force,
-        disableGenerators: {
-            actions: s.pathToActions === undefined,
-            businessLogic: s.pathToBusinessLogic === undefined,
-            data: s.pathToDataLib === undefined,
-            importExport: s.pathToImportExport === undefined,
-            react: s.reactFolderOutput === undefined,
-            seed: s.pathToSeedLib === undefined,
-            trpc: s.trpcRoutesFolder === undefined,
-            types: s.pathToTypes === undefined,
-        },
         userType: (0, types_1.toTypeName)(`User`),
     };
 });
@@ -173,100 +163,75 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
         for (const model of models) {
             const meta = (0, meta_1.getModelMetadata)({ model });
             // Types
-            if (!config.disableGenerators.types) {
-                generated.write(`/${meta.types.filePath}.ts`, (0, types_generator_3.generateModelTypes)({ model, meta }));
-            }
+            generated.write(`/${meta.types.filePath}.ts`, (0, types_generator_3.generateModelTypes)({ model, meta }));
             // Seed
-            if (!config.disableGenerators.seed) {
-                generated.write(`/${meta.seed.filePath}.ts`, (0, seed_generator_1.generateSeedModel)({ model, itemCount: 5, meta }));
-            }
+            generated.write(`/${meta.seed.filePath}.ts`, (0, seed_generator_1.generateSeedModel)({ model, itemCount: 5, meta }));
             // Data
-            if (!config.disableGenerators.data) {
-                generated.write(`/${meta.data.stubFilePath}.ts`, (0, stub_generator_1.generateStub)({ model, meta }));
-                generated.write(`/${meta.data.repository.filePath}.ts`, (0, repository_generator_1.generateRepository)({ model, meta }));
-                generated.write(`/${meta.data.mockRepository.filePath}.ts`, (0, repository_generator_1.generateMockRepository)({ model, meta }));
-                generated.write(`/${meta.e2e.dataMockerStubFilePath}.ts`, (0, stub_generator_1.generateStub)({ model, meta }));
-            }
+            generated.write(`/${meta.data.stubFilePath}.ts`, (0, stub_generator_1.generateStub)({ model, meta }));
+            generated.write(`/${meta.data.repository.filePath}.ts`, (0, repository_generator_1.generateRepository)({ model, meta }));
+            generated.write(`/${meta.data.mockRepository.filePath}.ts`, (0, repository_generator_1.generateMockRepository)({ model, meta }));
+            generated.write(`/${meta.e2e.dataMockerStubFilePath}.ts`, (0, stub_generator_1.generateStub)({ model, meta }));
             // Import-Export
-            if (!config.disableGenerators.importExport) {
-                generated.write(`/${meta.importExport.decoder.filePath}.ts`, (0, importexport_decoder_generator_1.generateModelImportExportDecoder)({ model, meta, schemaMeta: (0, meta_1.getSchemaMetadata)({ config }) }));
-            }
+            generated.write(`/${meta.importExport.decoder.filePath}.ts`, (0, importexport_decoder_generator_1.generateModelImportExportDecoder)({ model, meta, schemaMeta: (0, meta_1.getSchemaMetadata)({ config }) }));
             // Business Logic
-            if (!config.disableGenerators.businessLogic) {
-                generated.write(`/${meta.businessLogic.view.serviceFilePath}.ts`, (0, businesslogic_view_generator_1.generateModelBusinessLogicView)({ model, meta }));
-                generated.write(`/${meta.businessLogic.update.serviceFilePath}.ts`, (0, businesslogic_update_generator_1.generateModelBusinessLogicUpdate)({ model, meta }));
-            }
+            generated.write(`/${meta.businessLogic.view.serviceFilePath}.ts`, (0, businesslogic_view_generator_1.generateModelBusinessLogicView)({ model, meta }));
+            generated.write(`/${meta.businessLogic.update.serviceFilePath}.ts`, (0, businesslogic_update_generator_1.generateModelBusinessLogicUpdate)({ model, meta }));
             // Routes
-            if (!config.disableGenerators.trpc) {
-                generated.write(`/${meta.trpc.routerFilePath}.ts`, (0, route_generator_1.generateRoute)({ model, meta }));
-            }
+            generated.write(`/${meta.trpc.routerFilePath}.ts`, (0, route_generator_1.generateRoute)({ model, meta }));
             // React
-            if (!config.disableGenerators.react) {
-                yield generated.copy((0, react_generator_2.generateReactComponentsForModel)({ model, meta }), meta.react.folderPath);
-            }
+            yield generated.copy((0, react_generator_2.generateReactComponentsForModel)({ model, meta }), meta.react.folderPath);
             logger.log(`- ${model.name} processed`);
         }
         // Generate Enums
         for (const enumerator of enums.values()) {
             const meta = (0, meta_1.getEnumMetadata)({ enumerator });
-            if (!config.disableGenerators.types) {
-                generated.write(`/${meta.types.filePath}.ts`, (0, types_generator_1.generateEnumType)({ enumerator, prismaClientPath, meta }));
-            }
-            if (!config.disableGenerators.react) {
-                yield generated.copy((0, react_generator_1.generateEnumReactComponents)({ enumerator, meta }), meta.react.folderPath);
-            }
+            generated.write(`/${meta.types.filePath}.ts`, (0, types_generator_1.generateEnumType)({ enumerator, prismaClientPath, meta }));
+            yield generated.copy((0, react_generator_1.generateEnumReactComponents)({ enumerator, meta }), meta.react.folderPath);
         }
         // Generate Index Files and Services
         const meta = (0, meta_1.getSchemaMetadata)({ config });
-        if (!config.disableGenerators.data) {
-            generated.write(`/${meta.data.dataMockModuleFilePath}.ts`, (0, datamock_module_generator_1.generateDataMockModule)({ models, meta }));
-            generated.write(`/${meta.data.dataModuleFilePath}.ts`, (0, datamodule_generator_1.generateDataModule)({ models, meta }));
-            generated.write(`/${meta.data.dataService.filePath}.ts`, (0, dataservice_generator_1.generateDataService)({ models, meta }));
-            generated.write(`/${meta.data.testDataServiceFilePath}.ts`, (0, testdata_service_generator_1.generateTestDataService)({ models, meta }));
-            generated.write(`/${meta.e2e.dataMocker.filePath}.ts`, (0, datamocker_generator_1.generateDataMocker)({ models, meta }));
-            generated.write(`/${meta.e2e.selectorsFilePath}.ts`, (0, selectors_generator_1.generateSelectors)());
-            generated.write(`/${meta.e2e.dataMocker.stubIndexFilePath}.ts`, (0, stubs_generator_1.generateDataMockerStubsIndex)({ models, meta }));
-            generated.write(`/${meta.data.repository.constFilePath}.ts`, (0, repositories_generator_1.generateRepositoriesArray)({ models, meta }));
-            generated.write(`/${meta.data.repository.indexFilePath}.ts`, (0, repositories_generator_1.generateRepositoriesIndex)({ models, meta }));
-            generated.write(`/${meta.data.stubIndexFilePath}.ts`, (0, stubs_generator_1.generateStubsIndex)({ models, meta }));
-            generated.write(`/${meta.data.types.filePath}.ts`, (0, data_types_generator_1.generateDataTypes)({ models, meta }));
-            // We only generate the empty database migration if the migration folder already has an existing migration
-            // Else we would generate a migration that deletes from tables that have not yet been created in the database
-            // We include this check here as the template does not come with any migration - hence this migration should also not be generated
-            if ((0, emptydatabasemigration_generator_1.prismaMigrationExists)(meta)) {
-                generated.write((0, emptydatabasemigration_generator_1.deriveEmptyDatabaseMigrationFilePath)(meta), (0, emptydatabasemigration_generator_1.generateEmptyDatabaseStoredProcedure)({ models, meta }));
-            }
-        }
-        if (!config.disableGenerators.importExport) {
-            generated.write(`/${meta.importExport.types.filePath}.ts`, (0, importexport_types_generator_1.generateImportExportTypes)({ models, meta }));
-            generated.write(`/${meta.importExport.exporterClass.filePath}.ts`, (0, importexport_exporter_class_generator_1.generateImportExportExporterClass)({ models, meta }));
-            generated.write(`/${meta.importExport.importService.filePath}.ts`, (0, importexport_import_service_generator_1.generateImportExportImportService)({ models, meta }));
-            generated.write(`/${meta.importExport.decoder.indexFilePath}.ts`, (0, importexport_decoder_generator_1.generateImportExportDecoderIndex)({ models, meta }));
-            generated.write(`/${meta.importExport.decoder.fullDecoderFilePath}.ts`, (0, importexport_decoder_generator_1.generateImportExportDecoder)({ models, meta }));
-            generated.write(`/${meta.importExport.converterFunctions.filePath}.ts`, (0, importexport_convert_import_functions_generator_1.generateImportExportConvertImportFunctions)({ models, meta }));
-        }
-        if (!config.disableGenerators.actions) {
-            generated.write(`/${meta.actions.dispatcherService.filePath}.ts`, (0, dispatcher_service_generator_1.generateActionsDispatcherService)({ models, meta }));
-        }
-        if (!config.disableGenerators.businessLogic) {
-            generated.write(`/${meta.businessLogic.view.indexFilePath}.ts`, (0, businesslogic_view_index_generator_1.generateBusinessLogicViewIndex)({ models, meta }));
-            generated.write(`/${meta.businessLogic.view.moduleFilePath}.ts`, (0, businesslogic_view_module_generator_1.generateBusinessLogicViewModule)({ models, meta }));
-            generated.write(`/${meta.businessLogic.view.serviceFilePath}.ts`, (0, businesslogic_view_service_generator_1.generateBusinessLogicViewService)({ models, meta }));
-            generated.write(`/${meta.businessLogic.update.indexFilePath}.ts`, (0, businesslogic_update_index_generator_1.generateBusinessLogicUpdateIndex)({ models, meta }));
-            generated.write(`/${meta.businessLogic.update.moduleFilePath}.ts`, (0, businesslogic_update_module_generator_1.generateBusinessLogicUpdateModule)({ models, meta }));
-            generated.write(`/${meta.businessLogic.update.serviceFilePath}.ts`, (0, businesslogic_update_service_generator_1.generateBusinessLogicUpdateService)({ models, meta }));
-            generated.write(`/${meta.businessLogic.update.actionTypesFilePath}.ts`, (0, businesslogic_actiontypes_generator_1.generateBusinessLogicActionTypes)({ models, meta }));
-        }
-        if (!config.disableGenerators.seed) {
-            generated.write(`/${meta.seedData.initialMigrationFilePath}.ts`, (0, seed_migration_generator_1.generateSeedMigration)({ models, meta }));
-            generated.write(`/${meta.seedData.templateExcelFilePath}`, yield (0, seed_template_generator_1.generateSeedExcelTemplate)({ models }));
-        }
-        if (!config.disableGenerators.trpc) {
-            generated.write(`/${meta.trpc.routesFilePath}.ts`, (0, route_generator_1.generateRoutesIndex)({ models, meta }));
-        }
-        if (!config.disableGenerators.types) {
-            generated.write(`/${meta.types.indexFilePath}.ts`, (0, types_generator_2.generateTypesIndex)({ models, enums, meta }));
+        // Data
+        generated.write(`/${meta.data.dataMockModuleFilePath}.ts`, (0, datamock_module_generator_1.generateDataMockModule)({ models, meta }));
+        generated.write(`/${meta.data.dataModuleFilePath}.ts`, (0, datamodule_generator_1.generateDataModule)({ models, meta }));
+        generated.write(`/${meta.data.dataService.filePath}.ts`, (0, dataservice_generator_1.generateDataService)({ models, meta }));
+        generated.write(`/${meta.data.testDataServiceFilePath}.ts`, (0, testdata_service_generator_1.generateTestDataService)({ models, meta }));
+        generated.write(`/${meta.e2e.dataMocker.filePath}.ts`, (0, datamocker_generator_1.generateDataMocker)({ models, meta }));
+        generated.write(`/${meta.e2e.selectorsFilePath}.ts`, (0, selectors_generator_1.generateSelectors)());
+        generated.write(`/${meta.e2e.dataMocker.stubIndexFilePath}.ts`, (0, stubs_generator_1.generateDataMockerStubsIndex)({ models, meta }));
+        generated.write(`/${meta.data.repository.constFilePath}.ts`, (0, repositories_generator_1.generateRepositoriesArray)({ models, meta }));
+        generated.write(`/${meta.data.repository.indexFilePath}.ts`, (0, repositories_generator_1.generateRepositoriesIndex)({ models, meta }));
+        generated.write(`/${meta.data.stubIndexFilePath}.ts`, (0, stubs_generator_1.generateStubsIndex)({ models, meta }));
+        generated.write(`/${meta.data.types.filePath}.ts`, (0, data_types_generator_1.generateDataTypes)({ models, meta }));
+        // We only generate the empty database migration if the migration folder already has an existing migration
+        // Else we would generate a migration that deletes from tables that have not yet been created in the database
+        // We include this check here as the template does not come with any migration - hence this migration should also not be generated
+        if ((0, emptydatabasemigration_generator_1.prismaMigrationExists)(meta)) {
+            generated.write((0, emptydatabasemigration_generator_1.deriveEmptyDatabaseMigrationFilePath)(meta), (0, emptydatabasemigration_generator_1.generateEmptyDatabaseStoredProcedure)({ models, meta }));
         }
+        // Import-Export
+        generated.write(`/${meta.importExport.types.filePath}.ts`, (0, importexport_types_generator_1.generateImportExportTypes)({ models, meta }));
+        generated.write(`/${meta.importExport.exporterClass.filePath}.ts`, (0, importexport_exporter_class_generator_1.generateImportExportExporterClass)({ models, meta }));
+        generated.write(`/${meta.importExport.importService.filePath}.ts`, (0, importexport_import_service_generator_1.generateImportExportImportService)({ models, meta }));
+        generated.write(`/${meta.importExport.decoder.indexFilePath}.ts`, (0, importexport_decoder_generator_1.generateImportExportDecoderIndex)({ models, meta }));
+        generated.write(`/${meta.importExport.decoder.fullDecoderFilePath}.ts`, (0, importexport_decoder_generator_1.generateImportExportDecoder)({ models, meta }));
+        generated.write(`/${meta.importExport.converterFunctions.filePath}.ts`, (0, importexport_convert_import_functions_generator_1.generateImportExportConvertImportFunctions)({ models, meta }));
+        // Actions
+        generated.write(`/${meta.actions.dispatcherService.filePath}.ts`, (0, dispatcher_service_generator_1.generateActionsDispatcherService)({ models, meta }));
+        // Business Logic
+        generated.write(`/${meta.businessLogic.view.indexFilePath}.ts`, (0, businesslogic_view_index_generator_1.generateBusinessLogicViewIndex)({ models, meta }));
+        generated.write(`/${meta.businessLogic.view.moduleFilePath}.ts`, (0, businesslogic_view_module_generator_1.generateBusinessLogicViewModule)({ models, meta }));
+        generated.write(`/${meta.businessLogic.view.serviceFilePath}.ts`, (0, businesslogic_view_service_generator_1.generateBusinessLogicViewService)({ models, meta }));
+        generated.write(`/${meta.businessLogic.update.indexFilePath}.ts`, (0, businesslogic_update_index_generator_1.generateBusinessLogicUpdateIndex)({ models, meta }));
+        generated.write(`/${meta.businessLogic.update.moduleFilePath}.ts`, (0, businesslogic_update_module_generator_1.generateBusinessLogicUpdateModule)({ models, meta }));
+        generated.write(`/${meta.businessLogic.update.serviceFilePath}.ts`, (0, businesslogic_update_service_generator_1.generateBusinessLogicUpdateService)({ models, meta }));
+        generated.write(`/${meta.businessLogic.update.actionTypesFilePath}.ts`, (0, businesslogic_actiontypes_generator_1.generateBusinessLogicActionTypes)({ models, meta }));
+        // Seed
+        generated.write(`/${meta.seedData.initialMigrationFilePath}.ts`, (0, seed_migration_generator_1.generateSeedMigration)({ models, meta }));
+        generated.write(`/${meta.seedData.templateExcelFilePath}`, yield (0, seed_template_generator_1.generateSeedExcelTemplate)({ models }));
+        // Routes
+        generated.write(`/${meta.trpc.routesFilePath}.ts`, (0, route_generator_1.generateRoutesIndex)({ models, meta }));
+        // Types
+        generated.write(`/${meta.types.indexFilePath}.ts`, (0, types_generator_2.generateTypesIndex)({ models, enums, meta }));
         // -------------------------------------------------------------------------
         // Add disclaimer and format.
         yield generated.transformUTF8Files((path, content) => `${DISCLAIMER}\n${content}`);

package/dist/generators/indices/emptydatabasemigration.generator.js

@@ -45,11 +45,11 @@ exports.generateEmptyDatabaseStoredProcedure = generateEmptyDatabaseStoredProced
 function deriveEmptyDatabaseMigrationFilePath(meta) {
     const firstMigration = getFirstPrismaMigration(meta);
     if (firstMigration === undefined) {
-        throw new Error(`No Prisma migration found in ${meta.migrationsPath}! Please run "prisma migrate dev" first.`);
+        throw new Error(`No Prisma migration found in ${meta.prismaMigrationsPath}! Please run "prisma migrate dev" first.`);
     }
     const existingTimestamp = firstMigration.split('_')[0];
     const nextTimestamp = (Number.parseInt(existingTimestamp) + 1).toString();
-    return `/${meta.migrationsPath}/${nextTimestamp}_emptyDatabase/migration.sql`;
+    return `/${meta.prismaMigrationsPath}/${nextTimestamp}_emptyDatabase/migration.sql`;
 }
 exports.deriveEmptyDatabaseMigrationFilePath = deriveEmptyDatabaseMigrationFilePath;
 /**
@@ -64,7 +64,7 @@ exports.prismaMigrationExists = prismaMigrationExists;
  * Returns the first migration in the migrations folder if it exists.
  */
 function getFirstPrismaMigration(meta) {
-    const folder = meta.migrationsPath;
+    const folder = meta.prismaMigrationsPath;
     try {
         return fs_1.default.readdirSync(folder).find((f) => fs_1.default.statSync(`${folder}/${f}`).isDirectory());
     }

package/dist/generators/models/react.generator/lookup.generator.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateModelLookupComponents = void 0;
+const id_collector_1 = require("../../../lib/id-collector");
 const imports_1 = require("../../../lib/imports");
 /**
  * Utility generator that generates lookup components for a given model.
  */
 function generateModelLookupComponents({ model, meta }) {
     const { react: { context, components }, } = meta;
+    const selectorCollector = id_collector_1.SelectorCollector.from(meta.seed.constantName + '-formComponents');
     const imports = imports_1.ImportsGenerator.from(meta.react.folderPath)
         .addImport({
         items: [context.hookFnName],
@@ -26,7 +28,7 @@ function generateModelLookupComponents({ model, meta }) {
        * ${model.description} 
        */`;
     }
-    return `
+    return /* ts */ `
 import React from 'react'
 
 import { MenuSelectInput, MenuSelectField } from '@components/atoms/MenuSelect'
@@ -46,7 +48,16 @@ export const ${components.forms.selectInputName} = ({
   ...delegated
 }: UnionOmit<React.ComponentPropsWithoutRef<typeof SelectInput<${typeName}>>, ${tsOmittedFields}>) => {
   const { list, ready } = ${context.hookFnName}()
-  return <SelectInput<${typeName}> options={list} ${reactLabelField} loading={!ready} {...delegated} />
+  return <SelectInput<${typeName}> 
+    options={list}
+    ${reactLabelField}
+    loading={!ready} 
+    __cypress_field_selector__={
+        delegated.__cypress_field_selector__ 
+        ?? "${selectorCollector.idFor('', { typePrefix: 'selectInput' })}"
+      }
+    {...delegated}
+  />
 }
 
 ${description}
@@ -54,7 +65,16 @@ export const ${components.forms.selectFieldName} = ({
   ...delegated
 }: Omit<React.ComponentPropsWithoutRef<typeof SelectField<${typeName}>>, ${tsOmittedFields}>) => {
   const { list, ready } = ${context.hookFnName}()
-  return <SelectField<${typeName}> options={list} ${reactLabelField} loading={!ready} {...delegated} />
+  return <SelectField<${typeName}> 
+    options={list}
+    ${reactLabelField}
+    loading={!ready} 
+    __cypress_field_selector__={
+      delegated.__cypress_field_selector__ 
+      ?? "${selectorCollector.idFor('', { typePrefix: 'selectField' })}"
+    }
+    {...delegated}
+  />
 }
 
 // Menu Select
@@ -64,7 +84,16 @@ export const ${components.forms.menuSelectInputName} = ({
 	...delegated
 }: UnionOmit<React.ComponentPropsWithoutRef<typeof MenuSelectInput<${typeName}>>, ${tsOmittedFields}>) => {
 	const { list, ready } = ${context.hookFnName}()
-	return <MenuSelectInput<${typeName}> options={list} ${reactLabelField} loading={!ready} {...delegated} />
+	return <MenuSelectInput<${typeName}>
+    options={list}
+    ${reactLabelField}
+    loading={!ready} 
+    __cypress_options_selector__={
+      delegated.__cypress_options_selector__ 
+      ?? "${selectorCollector.idFor('', { typePrefix: 'menuSelectInput' })}"
+    }
+    {...delegated}
+  />
 }
 
 ${description}
@@ -72,7 +101,16 @@ export const ${components.forms.menuSelectFieldName} = ({
 	...delegated
 }: UnionOmit<React.ComponentPropsWithoutRef<typeof MenuSelectField<${typeName}>>, ${tsOmittedFields}>) => {
 	const { list, ready } = ${context.hookFnName}()
-	return <MenuSelectField<${typeName}> options={list} ${reactLabelField} loading={!ready} {...delegated} />
+	return <MenuSelectField<${typeName}>
+    options={list}
+    ${reactLabelField}
+    loading={!ready} 
+    __cypress_options_selector__={
+      delegated.__cypress_options_selector__ 
+      ?? "${selectorCollector.idFor('', { typePrefix: 'menuSelectField' })}"
+    }
+    {...delegated}
+  />
 }
 
 // Search
@@ -82,7 +120,20 @@ export const ${components.forms.searchInputName} = ({
 	...delegated
 }: UnionOmit<React.ComponentPropsWithoutRef<typeof SearchInput<${typeName}>>, ${tsOmittedFields}>) => {
 	const { list, ready } = ${context.hookFnName}()
-	return <SearchInput<${typeName}> options={list} ${reactLabelField} loading={!ready} {...delegated} />
+	return <SearchInput<${typeName}>
+    options={list}
+    ${reactLabelField}
+    loading={!ready} 
+    __cypress_combobox_selector__={
+      delegated.__cypress_combobox_selector__ 
+      ?? "${selectorCollector.idFor('field', { typePrefix: 'searchInput' })}"
+    }
+    __cypress_options_selector__={
+      delegated.__cypress_options_selector__ 
+      ?? "${selectorCollector.idFor('options', { typePrefix: 'searchInput' })}"
+    }
+    {...delegated}
+  />
 }
 
 ${description}
@@ -90,17 +141,38 @@ export const ${components.forms.searchFieldName} = ({
   ...delegated
 }: Omit<React.ComponentPropsWithoutRef<typeof SearchField<${typeName}>>, ${tsOmittedFields}>) => {
   const { list, ready } = ${context.hookFnName}()
-  return <SearchField<${typeName}> options={list} ${reactLabelField} loading={!ready} {...delegated} />
+  return <SearchField<${typeName}>
+    options={list}
+    ${reactLabelField}
+    loading={!ready} 
+    __cypress_combobox_selector__={
+      delegated.__cypress_combobox_selector__ 
+      ?? "${selectorCollector.idFor('field', { typePrefix: 'searchField' })}"
+    }
+    __cypress_options_selector__={
+      delegated.__cypress_options_selector__ 
+      ?? "${selectorCollector.idFor('options', { typePrefix: 'searchField' })}"
+    }
+    {...delegated}
+  />
 }
 
 // Table
-
 ${description}
 export const ${components.forms.tableSelectInputName} = ({
 	...delegated
 }: UnionOmit<React.ComponentPropsWithoutRef<typeof TableSelectInput<${typeName}>>, ${tsOmittedFields}>) => {
 	const { list, ready } = ${context.hookFnName}()
-	return <TableSelectInput<${typeName}> options={list} ${reactLabelField} loading={!ready} {...delegated} />
+	return <TableSelectInput<${typeName}>
+    options={list}
+    ${reactLabelField}
+    loading={!ready} 
+    __cypress_input_field_selector__={
+      delegated.__cypress_input_field_selector__
+      ?? "${selectorCollector.idFor('', { typePrefix: 'tableSelectInput' })}"
+    }
+    {...delegated}
+  />
 }
 
 ${description}
@@ -108,7 +180,16 @@ export const ${components.forms.tableSelectFieldName} = ({
 	...delegated
 }: UnionOmit<React.ComponentPropsWithoutRef<typeof TableSelectField<${typeName}>>, ${tsOmittedFields}>) => {
 	const { list, ready } = ${context.hookFnName}()
-	return <TableSelectField<${typeName}> options={list} ${reactLabelField} loading={!ready} {...delegated} />
+	return <TableSelectField<${typeName}>
+    options={list}
+    ${reactLabelField}
+    loading={!ready} 
+    __cypress_input_field_selector__={
+      delegated.__cypress_input_field_selector__ 
+      ?? "${selectorCollector.idFor('', { typePrefix: 'tableSelectField' })}"
+    }
+    {...delegated}
+  />
 }
 `;
 }

package/dist/generators/models/repository.generator.js

@@ -785,10 +785,6 @@ function generateUserRepositorySpecificBlocks_InDatabase({ model, meta, imports,
             rootUserInitializeBlock: '',
         };
     }
-    imports.addImport({
-        from: meta.types.importPath,
-        items: [(0, types_1.toVariableName)('UserRole')],
-    });
     const { rootUserId, rootUserValue } = generateSharedRootUserBlocks({ model, meta, imports });
     return {
         rootUserNameConst: `public static ROOT_USER_ID = ${meta.types.toBrandedIdTypeFnName}(${rootUserId})`,
@@ -868,7 +864,7 @@ function generateSharedRootUserBlocks({ model, meta, imports, }) {
         }
         else if (field.kind === 'id') {
             if (field.unbrandedTypeName === 'string') {
-                value = "rootId";
+                value = 'rootId';
             }
             else if (field.unbrandedTypeName === 'number') {
                 value = -1;

package/dist/lib/meta.d.ts

@@ -635,9 +635,9 @@ export type SchemaMetaData = {
         selectorsFilePath: Types.FilePath;
     };
     /**
-     * Path to the directory containing migrations.
+     * Path to the directory containing Prisma migrations.
      */
-    migrationsPath: Types.FilePath;
+    prismaMigrationsPath: Types.FilePath;
     /**
      * The schema configuration for reference.
      */

package/dist/lib/meta.js

@@ -251,7 +251,7 @@ function getSchemaMetadata({ config }) {
                 upsert: Types.toTypeName(`UpsertDTO`),
             },
         },
-        migrationsPath: Types.toPath(`${config.paths.migrationsFolderPath}`),
+        prismaMigrationsPath: Types.toPath(`${config.paths.prismaMigrationsFolderPath}`),
         config,
     };
 }

package/dist/lib/schema/schema.d.ts

@@ -7,43 +7,6 @@ import * as Types from './types';
  * NOTE: This may be accessed in every model, field and enumerator.
  */
 export type SchemaConfig = {
-    /**
-     * Indicates whether the generator should be ignored
-     */
-    disableGenerators: {
-        /**
-         * If true, actions module will not be generated.
-         */
-        actions: boolean;
-        /**
-         * If true, business logic module will not be generated.
-         */
-        businessLogic: boolean;
-        /**
-         * If true, data module will not be generated.
-         */
-        data: boolean;
-        /**
-         * If true, import-export module will not be generated.
-         */
-        importExport: boolean;
-        /**
-         * If true, seed data will not be generated.
-         */
-        seed: boolean;
-        /**
-         * If true, React components will not be generated.
-         */
-        react: boolean;
-        /**
-         * If true, trpc routes will not be generated.
-         */
-        trpc: boolean;
-        /**
-         * If true, type definitions for models will not be generated.
-         */
-        types: boolean;
-    };
     paths: {
         /**
          * Path to the directory containing actions.
@@ -84,7 +47,7 @@ export type SchemaConfig = {
         /**
          * Path to the directory containing Prisma migrations.
          */
-        migrationsFolderPath: Types.FilePath;
+        prismaMigrationsFolderPath: Types.FilePath;
         /**
          * Path to the directory containing model type definitions.
          *

package/dist/lib/utils/error.d.ts

@@ -3,3 +3,7 @@
  * By showing the error via console.log and throwing it again, we ensure that the error message is shown.
  */
 export declare function throwError(message: string): never;
+/**
+ * Extracts the error message from an error object or any other object.
+ */
+export declare function extractError(error: unknown): string;

package/dist/lib/utils/error.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.throwError = void 0;
+exports.extractError = exports.throwError = void 0;
 /**
  * Prisma generator often overwrites any error message because of some concurrency issues.
  * By showing the error via console.log and throwing it again, we ensure that the error message is shown.
@@ -11,3 +11,13 @@ function throwError(message) {
     throw new Error(m);
 }
 exports.throwError = throwError;
+/**
+ * Extracts the error message from an error object or any other object.
+ */
+function extractError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return JSON.stringify(error);
+}
+exports.extractError = extractError;

package/dist/prisma/parse.js

@@ -37,6 +37,7 @@ const REQUIRED_MODELS = ['User', 'Config', 'File', 'Action', 'Mutation'];
  */
 function parsePrismaSchema({ datamodel: { enums: enumsRaw, models: modelsRaw }, config, }) {
     ensureRequiredModelsExists(modelsRaw);
+    ensureConsistency({ models: modelsRaw, enums: enumsRaw });
     // NOTE: We preprocess models and enums so that we can populate relationships.
     const models = modelsRaw.map((dmmfModel) => parseModelCore({ dmmfModel, config }));
     const enums = enumsRaw.map((dmmfEnum) => parseEnum({ dmmfEnum, config }));
@@ -49,10 +50,60 @@ exports.parsePrismaSchema = parsePrismaSchema;
 function ensureRequiredModelsExists(models) {
     for (const requiredModel of REQUIRED_MODELS) {
         if (!models.find((m) => m.name === requiredModel)) {
-            (0, error_1.throwError)(`Required model ${requiredModel} not found in schema!`);
+            (0, error_1.throwError)(`Required model ${highlight(requiredModel)} not found in schema!`);
         }
     }
 }
+/**
+ * Validates:
+ * - That there are no duplicate model names
+ * - That model names are singular
+ * - That model attributes are valid
+ * - That field attributes are valid
+ * - That enum attributes are valid
+ */
+function ensureConsistency({ models, enums }) {
+    const errors = [];
+    const modelNames = models.map((m) => m.name);
+    const duplicateModelName = modelNames.find((name, i) => modelNames.indexOf(name) !== i);
+    if (duplicateModelName) {
+        errors.push(`Model ${duplicateModelName} is defined more than once.`);
+    }
+    for (const model of models) {
+        if ((0, string_1.isPlural)(model.name)) {
+            errors.push(`Model ${highlight(model.name)} is plural. Please use singular names for models.`);
+        }
+        try {
+            (0, attributes_1.getModelAttributes)(model);
+        }
+        catch (e) {
+            errors.push(`Model ${highlight(model.name)} has invalid model attributes: ${(0, error_1.extractError)(e)}`);
+        }
+    }
+    for (const model of models) {
+        for (const field of model.fields) {
+            try {
+                (0, attributes_1.getFieldAttributes)(field);
+            }
+            catch (e) {
+                errors.push(`Model ${highlight(model.name)} has invalid attributes for field ${highlight(field.name)}: 
+            ${(0, error_1.extractError)(e)}`);
+            }
+        }
+    }
+    for (const enumDef of enums) {
+        try {
+            (0, attributes_1.getEnumAttributes)(enumDef);
+        }
+        catch (e) {
+            errors.push(`Enum ${highlight(enumDef.name)} has invalid attributes: 
+        ${(0, error_1.extractError)(e)}`);
+        }
+    }
+    if (errors.length > 0) {
+        (0, error_1.throwError)(`${errors.length} ${(0, string_1.pluralize)('issue', errors.length)} detected in schema:\n   * ${errors.join('\n   * ')}`);
+    }
+}
 function isModelNotIgnored(model) {
     return model !== undefined && !model.attributes.ignore;
 }
@@ -98,14 +149,14 @@ function parseModel({ dmmfModel, enums, models, config, }) {
             continue;
         }
         if (dmmfField.relationFromFields.length > 1) {
-            throw new Error(`❌❌❌ Relation ${dmmfField.relationName} has more than one from field`);
+            (0, error_1.throwError)(`Field ${highlight(`${dmmfModel.name}.${dmmfField.relationName}`)} has more than one "from" field`);
         }
         const referencedModel = models.find((m) => m.sourceName === dmmfField.type);
         if (!referencedModel) {
-            (0, error_1.throwError)(`Investigate: Field references unknown model ${dmmfField.type}.`);
+            (0, error_1.throwError)(`Field ${highlight(`${dmmfModel.name}.${dmmfField.name}`)} references unknown model ${highlight(dmmfField.type)}.`);
         }
         if (dmmfField.relationOnDelete && dmmfField.relationOnDelete !== 'NoAction') {
-            (0, error_1.throwError)(`Investigate: "onDelete" attribute for relationship ${dmmfField.relationName} must be "NoAction": any deletes must be handled in the application layer, e.g. to update repository and search caches!`);
+            (0, error_1.throwError)(`Investigate model ${highlight(dmmfModel.name)}: "onDelete" attribute for relationship ${highlight(dmmfField.relationName)} must be "NoAction": any deletes must be handled in the application layer, e.g. to update repository and search caches!`);
         }
         relations[dmmfField.relationFromFields[0]] = referencedModel;
     }
@@ -123,6 +174,7 @@ function parseModel({ dmmfModel, enums, models, config, }) {
     dmmfField.kind !== 'object')
         .map((dmmfField) => {
         const attributes = (0, attributes_1.getFieldAttributes)(dmmfField);
+        const fieldName = highlight(`${dmmfModel.name}.${dmmfField.name}`);
         const shared = {
             name: Types.toFieldName((0, string_1.toCamelCase)(dmmfField.name)),
             description: attributes.description,
@@ -137,7 +189,7 @@ function parseModel({ dmmfModel, enums, models, config, }) {
             const refModel = relations[dmmfField.name];
             const refField = relationFields[dmmfField.name];
             if (!refField) {
-                (0, error_1.throwError)(`Investigate: Relation field ${dmmfField.name} not found.`);
+                (0, error_1.throwError)(`${fieldName}: Relation field ${highlight(dmmfField.name)} not found.`);
             }
             return Object.assign(Object.assign({ kind: 'relation' }, shared), { relatedModelBacklinkFieldName: Types.toFieldName(refField.name), typeName: Types.toTypeName(dmmfField.type), unbrandedTypeName: getTsTypeForId(dmmfField), relationToModel: refModel });
         }
@@ -148,7 +200,7 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         if (dmmfField.kind === 'scalar') {
             let validation = undefined;
             if (dmmfField.isList) {
-                (0, error_1.throwError)(`Array fields with scalars (e.g. String[]) aren't supported! Use a relation instead. Field: ${dmmfModel.name}.${dmmfField.name}`);
+                (0, error_1.throwError)(`${fieldName}: Array fields with scalars (e.g. String[]) aren't supported! Use a relation instead. `);
             }
             if (dmmfField.type === 'Int') {
                 validation = { type: 'int' };
@@ -161,11 +213,11 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         if (dmmfField.kind === 'enum') {
             const fieldEnumDef = enums.find((e) => e.sourceName === dmmfField.type);
             if (!fieldEnumDef) {
-                (0, error_1.throwError)(`Investigate: Field references unknown enum ${dmmfField.type}.`);
+                (0, error_1.throwError)(`${fieldName}: Field references unknown enum ${highlight(dmmfField.type)}.`);
             }
             return Object.assign(Object.assign({ kind: 'enum' }, shared), { typeName: getTsTypeForEnum(dmmfField), enumerator: fieldEnumDef });
         }
-        (0, error_1.throwError)(`Investigate: Field ${shared.sourceName}.${shared.sourceName} is not scalar, enum nor relation.`);
+        (0, error_1.throwError)(`${fieldName} is not scalar, enum nor relation.`);
     })
         .filter((field) => !isFieldIgnored({ field }));
     const { idField, defaultField, nameField, createdAtField, updatedAtField } = validateFields({ fields, model: core });
@@ -188,6 +240,7 @@ function validateFields({ fields, model: { name } }) {
     let nameField = undefined;
     let defaultField = undefined;
     for (const field of fields) {
+        const fieldName = highlight(`${name}.${field.name}`);
         switch (field.kind) {
             case 'scalar':
                 if (field.name === 'name') {
@@ -195,20 +248,20 @@ function validateFields({ fields, model: { name } }) {
                 }
                 if (field.attributes.isCreatedAt) {
                     if (createdAtField) {
-                        throw new Error(`❌❌❌ Model ${name} has multiple createdAt fields`);
+                        (0, error_1.throwError)(`${fieldName} has multiple createdAt fields`);
                     }
                     createdAtField = field;
                 }
                 if (field.attributes.isUpdatedAt) {
                     if (updatedAtField) {
-                        throw new Error(`❌❌❌ Model ${name} has multiple updatedAt fields`);
+                        (0, error_1.throwError)(`${fieldName} has multiple updatedAt fields`);
                     }
                     updatedAtField = field;
                 }
                 break;
             case 'id':
                 if (idField) {
-                    throw new Error(`❌❌❌ Model ${name} has multiple id fields`);
+                    (0, error_1.throwError)(`${fieldName} has multiple id fields`);
                 }
                 idField = field;
                 break;
@@ -220,20 +273,20 @@ function validateFields({ fields, model: { name } }) {
         //handle default case
         if (field.attributes.isDefaultField && field.kind === 'scalar') {
             if (defaultField !== undefined) {
-                throw new Error(`❌❌❌ Model ${name} has multiple default fields`);
+                (0, error_1.throwError)(`${fieldName} has multiple default fields`);
             }
             defaultField = field;
         }
         //handle name field
         if (field.attributes.isLabel) {
             if (labelField !== undefined) {
-                throw new Error(`❌❌❌ Model ${name} has multiple name fields`);
+                (0, error_1.throwError)(`${fieldName} has multiple name fields`);
             }
             labelField = field;
         }
     }
     if (!idField) {
-        throw new Error(`❌❌❌ Model ${name} does not have an id field`);
+        (0, error_1.throwError)(`Model ${highlight(name)} does not have an id field`);
     }
     return { idField, defaultField, nameField: (_a = labelField !== null && labelField !== void 0 ? labelField : nameField) !== null && _a !== void 0 ? _a : idField, createdAtField, updatedAtField };
 }
@@ -309,12 +362,12 @@ function getTsTypeForScalar(field) {
             return Types.toTypeName('number');
         case 'Json':
         case 'Bytes':
-            (0, error_1.throwError)('Not implemented yet');
+            (0, error_1.throwError)(`Field ${highlight(field.name)}: Type ${field.type} Not implemented yet`);
         // While TypeScript understands that throwError never returns, eslint doesn't and complains.
         // Hence we ignore the fallthrough error.
         // eslint-disable-next-line no-fallthrough
         default:
-            (0, error_1.throwError)(`Investigate: 'default' case in getTsTypeForScalar for field ${field.name} of type ${field.type}`);
+            (0, error_1.throwError)(`Investigate: 'default' case in getTsTypeForScalar for field ${highlight(field.name)} of type ${field.type}`);
     }
 }
 /**
@@ -332,7 +385,7 @@ function getTsTypeForId(field) {
         case 'Int':
             return Types.toTypeName('number');
         default:
-            (0, error_1.throwError)(`The id field ${field.name}  is of type ${field.type} - but only BigInt, Boolean, Decimal, Float, Int and String are supported for Ids.`);
+            (0, error_1.throwError)(`The id field ${highlight(field.name)} is of type ${field.type} - but only BigInt, Boolean, Decimal, Float, Int and String are supported for Ids.`);
     }
 }
 /**
@@ -347,9 +400,17 @@ function getTsTypeForEnum(field) {
         case 'Decimal':
         case 'Float':
         case 'Int':
-            (0, error_1.throwError)(`The enum field ${field.name}  is of type ${field.type} - but only String fields are supported for enums so far.`);
+            (0, error_1.throwError)(`The enum field ${highlight(field.name)} is of type ${field.type} - but only String fields are supported for enums so far.`);
             break;
         default:
             return Types.toTypeName(field.type);
     }
 }
+/**
+ * Highlights a string cyan
+ *
+ * NOTE: We would normally use `chalk.cyan` here, but this causes an error in the generator, so we use this workaround.
+ */
+function highlight(str) {
+    return `\u001B[36m${str}\u001B[39m`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "0.45.0",
+  "version": "0.47.0",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {