@kinotic-ai/kinotic-cli 1.0.2 → 2.0.0

package/README.md

@@ -12,7 +12,7 @@ $ npm install -g @kinotic-ai/kinotic-cli
 $ kinotic COMMAND
 running command...
 $ kinotic (--version)
-@kinotic-ai/kinotic-cli/1.0.2 darwin-arm64 node-v22.13.1
+@kinotic-ai/kinotic-cli/2.0.0 darwin-arm64 node-v22.13.1
 $ kinotic --help [COMMAND]
 USAGE
   $ kinotic COMMAND
@@ -22,6 +22,7 @@ USAGE
 # Commands
 <!-- commands -->
 * [`kinotic autocomplete [SHELL]`](#kinotic-autocomplete-shell)
+* [`kinotic create project NAME`](#kinotic-create-project-name)
 * [`kinotic gen`](#kinotic-gen)
 * [`kinotic generate`](#kinotic-generate)
 * [`kinotic help [COMMAND]`](#kinotic-help-command)
@@ -72,19 +73,40 @@ EXAMPLES
 
 _See code: [@oclif/plugin-autocomplete](https://github.com/oclif/plugin-autocomplete/blob/v3.2.41/src/commands/autocomplete/index.ts)_
 
+## `kinotic create project NAME`
+
+Creates a Kinotic Project
+
+```
+USAGE
+  $ kinotic create project NAME
+
+ARGUMENTS
+  NAME  The name for the project
+
+DESCRIPTION
+  Creates a Kinotic Project
+
+EXAMPLES
+  $ kinotic create project MyProjectName
+```
+
+_See code: [src/commands/create/project.ts](https://github.com/kinotic-ai/kinotic/blob/v2.0.0/src/commands/create/project.ts)_
+
 ## `kinotic gen`
 
-This will generate all Entity Service classes.
+This will generate all Repository classes.
 
 ```
 USAGE
-  $ kinotic gen [-v]
+  $ kinotic gen [-v] [-f]
 
 FLAGS
+  -f, --force    Force full regeneration, ignoring incremental change detection
   -v, --verbose  Enable verbose logging
 
 DESCRIPTION
-  This will generate all Entity Service classes.
+  This will generate all Repository classes.
 
 ALIASES
   $ kinotic gen
@@ -95,21 +117,24 @@ EXAMPLES
   $ kinotic gen
 
   $ kinotic gen -v
+
+  $ kinotic gen --force
 ```
 
 ## `kinotic generate`
 
-This will generate all Entity Service classes.
+This will generate all Repository classes.
 
 ```
 USAGE
-  $ kinotic generate [-v]
+  $ kinotic generate [-v] [-f]
 
 FLAGS
+  -f, --force    Force full regeneration, ignoring incremental change detection
   -v, --verbose  Enable verbose logging
 
 DESCRIPTION
-  This will generate all Entity Service classes.
+  This will generate all Repository classes.
 
 ALIASES
   $ kinotic gen
@@ -120,9 +145,11 @@ EXAMPLES
   $ kinotic gen
 
   $ kinotic gen -v
+
+  $ kinotic gen --force
 ```
 
-_See code: [src/commands/generate.ts](https://github.com/kinotic-ai/kinotic/blob/v1.0.2/src/commands/generate.ts)_
+_See code: [src/commands/generate.ts](https://github.com/kinotic-ai/kinotic/blob/v2.0.0/src/commands/generate.ts)_
 
 ## `kinotic help [COMMAND]`
 
@@ -150,12 +177,13 @@ This will initialize a new Kinotic Project for use with the Kinotic CLI.
 
 ```
 USAGE
-  $ kinotic init [-a <value>] [-e <value>] [-g <value>]
+  $ kinotic init [-a <value>] [-e <value>] [-r <value>] [-m]
 
 FLAGS
   -a, --application=<value>  The name of the application you want to use
   -e, --entities=<value>     Path to the directory containing the Entity definitions
-  -g, --generated=<value>    Path to the directory to write generated Services
+  -m, --mirror               Mirror the entity folder structure under the repository path
+  -r, --repository=<value>   Path to the directory to write generated Repository classes
 
 DESCRIPTION
   This will initialize a new Kinotic Project for use with the Kinotic CLI.
@@ -164,11 +192,13 @@ ALIASES
   $ kinotic init
 
 EXAMPLES
-  $ kinotic initialize --application my.app --entities path/to/entities --generated path/to/services
+  $ kinotic initialize --application my.app --entities path/to/entities --repository path/to/repository
 
-  $ kinotic init --application my.app --entities path/to/entities --generated path/to/services
+  $ kinotic init --application my.app --entities path/to/entities --repository path/to/repository
 
-  $ kinotic init -a my.app -e path/to/entities -g path/to/services
+  $ kinotic init -a my.app -e path/to/entities -r path/to/repository
+
+  $ kinotic init -a my.app -e path/to/entities -r path/to/repository --mirror
 ```
 
 ## `kinotic initialize`
@@ -177,12 +207,13 @@ This will initialize a new Kinotic Project for use with the Kinotic CLI.
 
 ```
 USAGE
-  $ kinotic initialize [-a <value>] [-e <value>] [-g <value>]
+  $ kinotic initialize [-a <value>] [-e <value>] [-r <value>] [-m]
 
 FLAGS
   -a, --application=<value>  The name of the application you want to use
   -e, --entities=<value>     Path to the directory containing the Entity definitions
-  -g, --generated=<value>    Path to the directory to write generated Services
+  -m, --mirror               Mirror the entity folder structure under the repository path
+  -r, --repository=<value>   Path to the directory to write generated Repository classes
 
 DESCRIPTION
   This will initialize a new Kinotic Project for use with the Kinotic CLI.
@@ -191,14 +222,16 @@ ALIASES
   $ kinotic init
 
 EXAMPLES
-  $ kinotic initialize --application my.app --entities path/to/entities --generated path/to/services
+  $ kinotic initialize --application my.app --entities path/to/entities --repository path/to/repository
+
+  $ kinotic init --application my.app --entities path/to/entities --repository path/to/repository
 
-  $ kinotic init --application my.app --entities path/to/entities --generated path/to/services
+  $ kinotic init -a my.app -e path/to/entities -r path/to/repository
 
-  $ kinotic init -a my.app -e path/to/entities -g path/to/services
+  $ kinotic init -a my.app -e path/to/entities -r path/to/repository --mirror
 ```
 
-_See code: [src/commands/initialize.ts](https://github.com/kinotic-ai/kinotic/blob/v1.0.2/src/commands/initialize.ts)_
+_See code: [src/commands/initialize.ts](https://github.com/kinotic-ai/kinotic/blob/v2.0.0/src/commands/initialize.ts)_
 
 ## `kinotic plugins`
 
@@ -496,7 +529,7 @@ Synchronize the local Entity definitions with the Kinotic Server
 
 ```
 USAGE
-  $ kinotic sync [-s <value>] [-p] [-v] [-f <value>] [--dryRun]
+  $ kinotic sync [-s <value>] [-p] [-v] [-f <value>] [--dryRun] [--force]
 
 FLAGS
   -f, --authHeaderFile=<value>  JSON File containing authentication headers
@@ -504,6 +537,7 @@ FLAGS
   -s, --server=<value>          The Kinotic server to connect to
   -v, --verbose                 Enable verbose logging
       --dryRun                  Dry run enables verbose logging and does not save any changes to the server
+      --force                   Force full regeneration, ignoring incremental change detection
 
 DESCRIPTION
   Synchronize the local Entity definitions with the Kinotic Server
@@ -527,7 +561,7 @@ Synchronize the local Entity definitions with the Kinotic Server
 
 ```
 USAGE
-  $ kinotic synchronize [-s <value>] [-p] [-v] [-f <value>] [--dryRun]
+  $ kinotic synchronize [-s <value>] [-p] [-v] [-f <value>] [--dryRun] [--force]
 
 FLAGS
   -f, --authHeaderFile=<value>  JSON File containing authentication headers
@@ -535,6 +569,7 @@ FLAGS
   -s, --server=<value>          The Kinotic server to connect to
   -v, --verbose                 Enable verbose logging
       --dryRun                  Dry run enables verbose logging and does not save any changes to the server
+      --force                   Force full regeneration, ignoring incremental change detection
 
 DESCRIPTION
   Synchronize the local Entity definitions with the Kinotic Server
@@ -552,7 +587,7 @@ EXAMPLES
   $ kinotic sync -p -v -s http://localhost:9090
 ```
 
-_See code: [src/commands/synchronize.ts](https://github.com/kinotic-ai/kinotic/blob/v1.0.2/src/commands/synchronize.ts)_
+_See code: [src/commands/synchronize.ts](https://github.com/kinotic-ai/kinotic/blob/v2.0.0/src/commands/synchronize.ts)_
 
 ## `kinotic update [CHANNEL]`
 

package/dist/commands/create/project.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export declare class Project extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private renderProjectModule;
+}

package/dist/commands/create/project.js

@@ -0,0 +1,62 @@
+import { Args, Command } from '@oclif/core';
+import { input, select } from '@inquirer/prompts';
+import chalk from 'chalk';
+import ora from 'ora';
+import path from 'node:path';
+import process from 'node:process';
+import { spawnEngine } from '../../internal/spawn/SpawnEngine.js';
+import { createFrontEnd } from '../../internal/CommandHelper.js';
+export class Project extends Command {
+    static description = 'Creates a Kinotic Project';
+    static examples = [
+        '$ kinotic create project MyProjectName',
+    ];
+    static args = {
+        name: Args.string({ description: 'The name for the project', required: true })
+    };
+    async run() {
+        const { args } = await this.parse(Project);
+        const projectDir = path.resolve(args.name);
+        let context = { projectName: args.name };
+        this.log(chalk.cyan('Creating Kinotic Project'));
+        const spinner = ora('Generating project...').start();
+        try {
+            context = (await spawnEngine.renderSpawn('project', projectDir, context)) ?? context;
+            spinner.succeed(chalk.green('Project generated'));
+        }
+        catch (err) {
+            spinner.fail('Project generation failed');
+            throw err;
+        }
+        process.chdir(projectDir);
+        let choice;
+        do {
+            choice = await select({
+                message: 'What would you like to add?',
+                choices: [{ value: 'Library' }, { value: 'Frontend' }, { value: 'Quit' }]
+            });
+            switch (choice) {
+                case 'Library': {
+                    const libraryName = await input({ message: 'Library Name' });
+                    context.libraryName = libraryName;
+                    await this.renderProjectModule('library', libraryName, projectDir, context);
+                    break;
+                }
+                case 'Frontend': {
+                    const name = await input({ message: 'Project Name' });
+                    await createFrontEnd(name);
+                    break;
+                }
+                case 'Quit':
+                    break;
+            }
+        } while (choice !== 'Quit');
+    }
+    async renderProjectModule(spawn, name, projectDir, context) {
+        const dir = path.resolve(name);
+        if (!dir.startsWith(projectDir)) {
+            throw new Error(`Module dir ${dir} must be within ${projectDir}`);
+        }
+        await spawnEngine.renderSpawn(spawn, dir, context);
+    }
+}

package/dist/commands/generate.d.ts

@@ -4,7 +4,8 @@ export declare class Generate extends Command {
     static description: string;
     static examples: string[];
     static flags: {
-        verbose: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
     logVerbose(message: string | (() => string), verbose: boolean): void;

package/dist/commands/generate.js

@@ -1,16 +1,18 @@
-import { CodeGenerationService } from '../internal/CodeGenerationService.js';
+import { EntityCodeGenerationService } from '../internal/EntityCodeGenerationService.js';
 import { Command, Flags } from '@oclif/core';
 import { isKinoticProject, loadKinoticProjectConfig } from '../internal/state/KinoticProjectConfigUtil.js';
 export class Generate extends Command {
     static aliases = ['gen'];
-    static description = 'This will generate all Entity Service classes.';
+    static description = 'This will generate all Repository classes.';
     static examples = [
         '$ kinotic generate',
         '$ kinotic gen',
         '$ kinotic gen -v',
+        '$ kinotic gen --force',
     ];
     static flags = {
         verbose: Flags.boolean({ char: 'v', description: 'Enable verbose logging', default: false }),
+        force: Flags.boolean({ char: 'f', description: 'Force full regeneration, ignoring incremental change detection', default: false }),
     };
     async run() {
         const { flags } = await this.parse(Generate);
@@ -18,8 +20,8 @@ export class Generate extends Command {
             this.error('The working directory is not a Kinotic Project');
         }
         const kinoticProjectConfig = await loadKinoticProjectConfig();
-        const codeGenerationService = new CodeGenerationService(kinoticProjectConfig.application, kinoticProjectConfig.fileExtensionForImports, this);
-        await codeGenerationService.generateAllEntities(kinoticProjectConfig, flags.verbose);
+        const codeGenerationService = new EntityCodeGenerationService(kinoticProjectConfig.application, kinoticProjectConfig.fileExtensionForImports, this);
+        await codeGenerationService.generateAllEntities(kinoticProjectConfig, flags.verbose, undefined, flags.force);
         this.log(`Code Generation Complete For application: ${kinoticProjectConfig.application}`);
     }
     // This is needed for the CodeGenerationService to log verbose messages

package/dist/commands/initialize.d.ts

@@ -4,9 +4,10 @@ export declare class Initialize extends Command {
     static description: string;
     static examples: string[];
     static flags: {
-        application: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        entities: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        generated: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        application: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        entities: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        repository: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        mirror: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/initialize.js

@@ -28,14 +28,16 @@ export class Initialize extends Command {
     static aliases = ['init'];
     static description = 'This will initialize a new Kinotic Project for use with the Kinotic CLI.';
     static examples = [
-        '$ kinotic initialize --application my.app --entities path/to/entities --generated path/to/services',
-        '$ kinotic init --application my.app --entities path/to/entities --generated path/to/services',
-        '$ kinotic init -a my.app -e path/to/entities -g path/to/services',
+        '$ kinotic initialize --application my.app --entities path/to/entities --repository path/to/repository',
+        '$ kinotic init --application my.app --entities path/to/entities --repository path/to/repository',
+        '$ kinotic init -a my.app -e path/to/entities -r path/to/repository',
+        '$ kinotic init -a my.app -e path/to/entities -r path/to/repository --mirror',
     ];
     static flags = {
         application: Flags.string({ char: 'a', description: 'The name of the application you want to use', required: false }),
         entities: Flags.string({ char: 'e', description: 'Path to the directory containing the Entity definitions', required: false }),
-        generated: Flags.string({ char: 'g', description: 'Path to the directory to write generated Services', required: false }),
+        repository: Flags.string({ char: 'r', description: 'Path to the directory to write generated Repository classes', required: false }),
+        mirror: Flags.boolean({ char: 'm', description: 'Mirror the entity folder structure under the repository path', default: true }),
     };
     async run() {
         const { flags } = await this.parse(Initialize);
@@ -67,33 +69,36 @@ export class Initialize extends Command {
         if (!entitiesPath) {
             entitiesPath = await input({
                 message: 'Path to the directory containing Entity definitions:',
-                default: 'src/entities',
+                default: 'src/model',
                 validate: (input) => input.trim() !== '' || 'Entities path is required'
             });
         }
-        let generatedPath = flags.generated;
-        if (!generatedPath) {
-            generatedPath = await input({
-                message: 'Path to the directory to write generated Services:',
-                default: 'src/generated',
-                validate: (input) => input.trim() !== '' || 'Generated path is required'
+        let repositoryPath = flags.repository;
+        if (!repositoryPath) {
+            repositoryPath = await input({
+                message: 'Path to the directory to write generated Repository classes:',
+                default: 'src/repository',
+                validate: (input) => input.trim() !== '' || 'Repository path is required'
             });
         }
         const entitiesAbsPath = path.resolve(entitiesPath);
-        const generatedAbsPath = path.resolve(generatedPath);
+        const repositoryAbsPath = path.resolve(repositoryPath);
         if (!fs.existsSync(entitiesAbsPath)) {
             this.error(`Entities path does not exist: ${entitiesAbsPath}`);
         }
-        if (!fs.existsSync(generatedAbsPath)) {
-            this.error(`Generated path does not exist: ${generatedAbsPath}`);
+        if (!fs.existsSync(repositoryAbsPath)) {
+            this.error(`Repository path does not exist: ${repositoryAbsPath}`);
         }
         // Only use TypescriptProjectConfig for initialization
         const configDir = path.resolve(process.cwd(), '.config');
         const configObj = new KinoticProjectConfig();
         // Don't set name - it will be loaded from package.json
         configObj.application = application;
-        configObj.entitiesPaths = [entitiesPath];
-        configObj.generatedPath = generatedPath;
+        configObj.entitiesPaths = [{
+                path: entitiesPath,
+                repositoryPath: repositoryPath,
+                mirrorFolderStructure: flags.mirror
+            }];
         configObj.validate = false;
         configObj.fileExtensionForImports = '.js';
         await saveKinoticProjectConfig(configObj, configDir);

package/dist/commands/synchronize.d.ts

@@ -4,11 +4,12 @@ export declare class Synchronize extends Command {
     static description: string;
     static examples: string[];
     static flags: {
-        server: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        publish: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
-        verbose: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
-        authHeaderFile: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        dryRun: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        server: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        publish: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        authHeaderFile: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        dryRun: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
     logVerbose(message: string | (() => string), verbose: boolean): void;

package/dist/commands/synchronize.js

@@ -4,7 +4,7 @@ import { EntityDefinition, NamedQueriesDefinition, OsApiPlugin, Project, Project
 import { Command, Flags } from '@oclif/core';
 import chalk from 'chalk';
 import { WebSocket } from 'ws';
-import { CodeGenerationService } from '../internal/CodeGenerationService.js';
+import { EntityCodeGenerationService } from '../internal/EntityCodeGenerationService.js';
 import { ProjectMigrationService } from '../internal/ProjectMigrationService.js';
 import { resolveServer } from '../internal/state/Environment.js';
 import { connectAndUpgradeSession } from '../internal/Utils.js';
@@ -25,7 +25,8 @@ export class Synchronize extends Command {
         publish: Flags.boolean({ char: 'p', description: 'Publish each Entity after save/update' }),
         verbose: Flags.boolean({ char: 'v', description: 'Enable verbose logging' }),
         authHeaderFile: Flags.string({ char: 'f', description: 'JSON File containing authentication headers', required: false }),
-        dryRun: Flags.boolean({ description: 'Dry run enables verbose logging and does not save any changes to the server' })
+        dryRun: Flags.boolean({ description: 'Dry run enables verbose logging and does not save any changes to the server' }),
+        force: Flags.boolean({ description: 'Force full regeneration, ignoring incremental change detection', default: false })
     };
     async run() {
         const { flags } = await this.parse(Synchronize);
@@ -48,7 +49,7 @@ export class Synchronize extends Command {
                         project.sourceOfTruth = ProjectType.TYPESCRIPT;
                         project = await Kinotic.projects.createProjectIfNotExist(project);
                     }
-                    const codeGenerationService = new CodeGenerationService(kinoticProjectConfig.application, kinoticProjectConfig.fileExtensionForImports, this);
+                    const codeGenerationService = new EntityCodeGenerationService(kinoticProjectConfig.application, kinoticProjectConfig.fileExtensionForImports, this);
                     await codeGenerationService
                         .generateAllEntities(kinoticProjectConfig, flags.verbose || flags.dryRun, async (entityInfo, services) => {
                         // combine named queries from generated services
@@ -66,7 +67,7 @@ export class Synchronize extends Command {
                         if (!flags.dryRun) {
                             await this.synchronizeEntity(project.id, entityInfo.entity, flags.publish, flags.verbose);
                         }
-                    });
+                    }, flags.force);
                     // Apply migrations after entity synchronization
                     if (!flags.dryRun) {
                         const migrationService = new ProjectMigrationService(this);

package/dist/internal/CommandHelper.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Creates a new front end project using either React or Vue depending on the user's choice
+ */
+export declare function createFrontEnd(name: string): Promise<void>;

package/dist/internal/CommandHelper.js

@@ -0,0 +1,29 @@
+import { select } from '@inquirer/prompts';
+import { execa } from 'execa';
+/**
+ * Creates a new front end project using either React or Vue depending on the user's choice
+ */
+export async function createFrontEnd(name) {
+    const framework = await select({
+        message: 'Which framework would you like to use?',
+        choices: [{ value: 'React' }, { value: 'Vue' }]
+    });
+    if (framework === 'React') {
+        await createReact(name);
+    }
+    else {
+        await createVue(name);
+    }
+}
+/**
+ * Creates a new React project using create-react-app
+ */
+async function createReact(name) {
+    await execa('npx', ['create-react-app', name], { stdio: 'inherit' });
+}
+/**
+ * Creates a new Vue project using vue-cli with npx
+ */
+async function createVue(name) {
+    await execa('npx', ['@vue/cli', 'create', name], { stdio: 'inherit' });
+}

package/dist/internal/{CodeGenerationService.d.ts → EntityCodeGenerationService.d.ts}

@@ -5,16 +5,25 @@ export type GeneratedEntityProcessor = (entityInfo: EntityInfo, serviceInfo: Gen
 /**
  * Helper service for generating code.s
  */
-export declare class CodeGenerationService {
+export declare class EntityCodeGenerationService {
     private readonly fileExtensionForImports;
     private readonly logger;
     private readonly engine;
     private readonly tsMorphProject;
     private readonly conversionContext;
     constructor(application: string, fileExtensionForImports: string, logger: Logger);
-    generateAllEntities(projectConfig: KinoticProjectConfig, verbose: boolean, entityProcessor?: GeneratedEntityProcessor): Promise<void>;
+    generateAllEntities(projectConfig: KinoticProjectConfig, verbose: boolean, entityProcessor?: GeneratedEntityProcessor, force?: boolean): Promise<void>;
+    /**
+     * Normalizes an entitiesPaths entry into a fully resolved {@link EntitiesPathConfig}.
+     */
+    private resolveEntitiesPathConfig;
     private processEntities;
-    private generateEntityService;
+    /**
+     * Resolves the output path for generated repository files based on the entity's source location
+     * and the path configuration.
+     */
+    private resolveRepositoryOutputPath;
+    private generateRepository;
     /**
      * Adds invocation logic to named queries and returns the {@link FunctionDefinition}s that define them.
      */