@kinotic-ai/kinotic-cli 1.0.2 → 2.0.0

package/dist/internal/spawn/SpawnEngine.js

@@ -0,0 +1,187 @@
+import fs from 'node:fs';
+import fsP from 'node:fs/promises';
+import path from 'node:path';
+import { Liquid } from 'liquidjs';
+import { confirm, input, number, select } from '@inquirer/prompts';
+import { SpawnConfigSchema } from './SpawnConfig.js';
+import { spawnResolver } from './SpawnResolver.js';
+function upperFirst(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function camelCase(s) {
+    return s
+        .replace(/[-_\s]+(.)/g, (_, c) => c.toUpperCase())
+        .replace(/^(.)/, (_, c) => c.toLowerCase());
+}
+export default class SpawnEngine {
+    engine;
+    spawnResolver;
+    constructor(resolver) {
+        this.spawnResolver = resolver;
+        this.engine = new Liquid({ cache: true });
+        this.engine.registerFilter('packageToPath', (v) => v.replaceAll('.', '/'));
+        this.engine.registerFilter('encodePackage', (v) => {
+            v = v.replaceAll('-', '_');
+            v = v.replace(/\.(\d+)/g, '._$1');
+            return v;
+        });
+        this.engine.registerFilter('camelCase', (v) => camelCase(v));
+        this.engine.registerFilter('upperFirst', (v) => upperFirst(v));
+    }
+    /**
+     * Renders the specified Spawn
+     * A Spawn is a directory that contains templates, an optional spawn.json file, and template parameters in folder and filenames
+     *
+     * This is done by performing the following
+     *
+     * - Will recursively walk the spawn copying any files or directories encountered
+     * -- If a template file is encountered, it will be parsed and rendered prior to copying
+     *
+     * @param spawn the name of the spawn to parse and render. This is the name of the directory containing the spawn.json
+     * @param destination the target directory where rendered data will be sent
+     * @param context the values to be provided to the templates while rendering
+     * @return a promise containing all the original values plus any added during rendering
+     */
+    async renderSpawn(spawn, destination, context) {
+        let contextInternal;
+        if (!fs.existsSync(destination)) {
+            const source = await this.spawnResolver.resolveSpawn(spawn);
+            const sources = [source];
+            const currentConfigPath = path.resolve(source, 'spawn.json');
+            if (fs.existsSync(currentConfigPath)) {
+                const spawns = [];
+                let currentConfig = currentConfigPath;
+                let currentSpawn = SpawnConfigSchema.parse(JSON.parse(fs.readFileSync(currentConfig, { encoding: 'utf8' })));
+                spawns.push(currentSpawn);
+                // follow inheritance and build stack
+                while (currentSpawn.inherits) {
+                    const inheritDir = path.resolve(path.dirname(currentConfig), currentSpawn.inherits);
+                    currentConfig = path.resolve(inheritDir, 'spawn.json');
+                    this.logDebug(`Inheriting from ${currentConfig}\n`);
+                    if (!fs.existsSync(currentConfig)) {
+                        throw new Error(`Inherited spawn ${currentConfig} does not exist`);
+                    }
+                    currentSpawn = SpawnConfigSchema.parse(JSON.parse(fs.readFileSync(currentConfig, { encoding: 'utf8' })));
+                    spawns.push(currentSpawn);
+                    sources.push(inheritDir);
+                }
+                let globals = {};
+                let propertySchemas = {};
+                for (const spawnConfig of spawns.reverse()) {
+                    if (spawnConfig.globals) {
+                        globals = { ...globals, ...spawnConfig.globals };
+                    }
+                    if (spawnConfig.propertySchema) {
+                        propertySchemas = { ...propertySchemas, ...spawnConfig.propertySchema };
+                    }
+                }
+                contextInternal = { ...globals, ...context };
+                contextInternal = await this.promptForMissingProperties(propertySchemas, contextInternal);
+            }
+            await fsP.mkdir(destination, { recursive: true });
+            for (const src of sources.reverse()) {
+                await this._renderDirectory(src, src, destination, contextInternal);
+            }
+            return contextInternal;
+        }
+        else {
+            throw new Error(`The target directory ${destination} already exists`);
+        }
+    }
+    async promptForMissingProperties(propertySchema, context) {
+        const ret = context ? { ...context } : {};
+        let hasPrompted = false;
+        for (const key in propertySchema) {
+            if (!Object.prototype.hasOwnProperty.call(ret, key)) {
+                if (!hasPrompted) {
+                    console.log('Please provide the following...\n');
+                    hasPrompted = true;
+                }
+                const schema = propertySchema[key];
+                let message;
+                if (schema.description?.includes('{{')) {
+                    message = this.engine.parseAndRenderSync(schema.description, ret);
+                }
+                else {
+                    message = schema.description ?? key;
+                }
+                let defaultValue;
+                if (typeof schema.default === 'string' && schema.default.includes('{{')) {
+                    defaultValue = this.engine.parseAndRenderSync(schema.default, ret);
+                }
+                else {
+                    defaultValue = schema.default;
+                }
+                if (schema.type === 'boolean') {
+                    ret[key] = await confirm({ message, default: typeof defaultValue === 'boolean' ? defaultValue : undefined });
+                }
+                else if (schema.enum) {
+                    ret[key] = await select({
+                        message,
+                        choices: schema.enum.map((v) => ({ value: v })),
+                        default: defaultValue !== undefined ? String(defaultValue) : undefined
+                    });
+                }
+                else if (schema.type === 'number' || schema.type === 'integer') {
+                    ret[key] = await number({ message, default: typeof defaultValue === 'number' ? defaultValue : undefined });
+                }
+                else {
+                    ret[key] = await input({ message, default: typeof defaultValue === 'string' ? defaultValue : undefined });
+                }
+            }
+        }
+        return ret;
+    }
+    async _renderFile(source, destination, errorIfExists, context) {
+        if (destination.includes('{{')) {
+            destination = await this.engine.parseAndRender(destination, context ?? {});
+        }
+        let overwritingFile = false;
+        if ((errorIfExists) && fs.existsSync(destination)) {
+            if (errorIfExists) {
+                throw new Error(`The target file ${destination} already exists`);
+            }
+            overwritingFile = true;
+        }
+        let readStream;
+        if (destination.endsWith('.liquid')) {
+            destination = destination.substring(0, destination.length - 7);
+            readStream = await this.engine.renderFileToNodeStream(source, context ?? {});
+        }
+        else {
+            readStream = fs.createReadStream(source);
+        }
+        this.logDebug(`${overwritingFile ? 'Overwriting' : 'Writing'} File\n${source}\nto\n${destination}\n`);
+        await fsP.mkdir(path.dirname(destination), { recursive: true });
+        const writeStream = fs.createWriteStream(destination);
+        readStream.pipe(writeStream);
+    }
+    async _renderDirectory(baseFrom, from, baseTo, context) {
+        const files = await fsP.readdir(from, { withFileTypes: true });
+        for (const file of files) {
+            const filePath = path.resolve(from, file.name);
+            const to = filePath.replace(baseFrom, baseTo);
+            if (file.isFile()) {
+                if (!this.shouldIgnore(file.name)) {
+                    await this._renderFile(filePath, to, false, context);
+                }
+                else {
+                    this.logDebug(`Skipping File\n${filePath}\n`);
+                }
+            }
+            else {
+                await this._renderDirectory(baseFrom, filePath, baseTo, context);
+            }
+        }
+    }
+    logDebug(message) {
+        if (process.env.DEBUG) {
+            console.debug(message);
+        }
+    }
+    shouldIgnore(fileName) {
+        const filesToSkip = ['.DS_Store', 'spawn.json'];
+        return filesToSkip.includes(fileName);
+    }
+}
+export const spawnEngine = new SpawnEngine(spawnResolver);

package/dist/internal/spawn/SpawnResolver.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Handles resolving "Spawn"s on the local filesystem
+ */
+export interface SpawnResolver {
+    /**
+     * Finds the correct absolute path for the spawn provided.
+     *
+     * @param spawn the name of desired spawn. Ex: project, library
+     * @return a {@link Promise} containing the absolute path or an error if the spawn could not be found
+     */
+    resolveSpawn(spawn: string): Promise<string>;
+}
+declare class DefaultSpawnResolver implements SpawnResolver {
+    resolveSpawn(spawn: string): Promise<string>;
+}
+export declare const spawnResolver: DefaultSpawnResolver;
+export {};

package/dist/internal/spawn/SpawnResolver.js

@@ -0,0 +1,14 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'url';
+const bundledTemplatesRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../templates/spawns/');
+class DefaultSpawnResolver {
+    async resolveSpawn(spawn) {
+        const spawnDir = path.resolve(bundledTemplatesRoot, spawn);
+        if (fs.existsSync(spawnDir)) {
+            return spawnDir;
+        }
+        throw new Error(`No spawn could be found with the name ${spawn}`);
+    }
+}
+export const spawnResolver = new DefaultSpawnResolver();

package/dist/templates/entity/AdminRepository.liquid

@@ -0,0 +1,14 @@
+import { type IAdminEntitiesService } from '@kinotic-ai/persistence'
+import { Base{{ entityName }}AdminRepository } from './generated/Base{{ entityName }}AdminRepository{{ fileExtensionForImports }}'
+
+/**
+ * Admin Repository for interacting with {{ entityName }} entities
+ * This class was generated by the Kinotic CLI
+ */
+export class {{ entityName }}AdminRepository extends Base{{ entityName }}AdminRepository {
+
+  constructor(adminEntitiesService?: IAdminEntitiesService) {
+    super(adminEntitiesService)
+  }
+
+}

package/dist/templates/{BaseAdminEntityService.liquid → entity/BaseAdminRepository.liquid}

@@ -7,10 +7,10 @@ import { {{ entityName }} } from '{{ entityImportPath }}'
 {{ importStatements }}
 
 /**
- * Admin Base Service for interacting with {{ entityName }} entities
+ * Admin Base Repository for interacting with {{ entityName }} entities
  * This class was generated by the Kinotic CLI. And will be overwritten if the CLI is run again.
  */
-export class Base{{ entityName }}AdminEntityService extends AdminEntityService<{{ entityName }}> {
+export class Base{{ entityName }}AdminRepository extends AdminEntityService<{{ entityName }}> {
 
   constructor(adminEntitiesService?: IAdminEntitiesService) {
     super('{{ entityNamespace }}', '{{ entityName }}', adminEntitiesService)

package/dist/templates/{BaseEntityService.liquid → entity/BaseRepository.liquid}

@@ -7,10 +7,10 @@ import { {{ entityName }} } from '{{ entityImportPath }}'
 {{ importStatements }}
 
 /**
- * Base Service for interacting with {{ entityName }} entities
+ * Base Repository for interacting with {{ entityName }} entities
  * This class was generated by the Kinotic CLI. And will be overwritten if the CLI is run again.
  */
-export class Base{{ entityName }}EntityService extends EntityService<{{ entityName }}> {
+export class Base{{ entityName }}Repository extends EntityService<{{ entityName }}> {
 
   private readonly shouldValidate: boolean
 

package/dist/templates/entity/Repository.liquid

@@ -0,0 +1,14 @@
+import { type IEntitiesService } from '@kinotic-ai/persistence'
+import { Base{{ entityName }}Repository } from './generated/Base{{ entityName }}Repository{{ fileExtensionForImports }}'
+
+/**
+ * Repository for interacting with {{ entityName }} entities
+ * This class was generated by the Kinotic CLI
+ */
+export class {{ entityName }}Repository extends Base{{ entityName }}Repository {
+
+  constructor(entitiesService?: IEntitiesService) {
+    super({{ validate }}, entitiesService)
+  }
+
+}

package/dist/templates/spawns/library/package.json.liquid

@@ -0,0 +1,30 @@
+{
+  "name": "{{ libraryName }}",
+  "version": "0.1.0",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "type-check": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "typescript": ">=4.5.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts"
+}

package/dist/templates/spawns/library/spawn.json

@@ -0,0 +1,8 @@
+{
+  "propertySchema":{
+    "libraryName": {
+      "type": "string",
+      "description": "The name of the library you want to create"
+    }
+  }
+}

package/dist/templates/spawns/library/src/index.ts

@@ -0,0 +1,3 @@
+export function greet(name: string): string {
+	return `Hello, ${name}! Welcome to the domain package.`
+}

package/dist/templates/spawns/library/tsconfig.json

@@ -0,0 +1,5 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"compilerOptions": { "declaration": true, "isolatedDeclarations": true },
+	"include": ["src/**/*"]
+}

package/dist/templates/spawns/project/.config/kinotic.config.ts.liquid

@@ -0,0 +1,16 @@
+import type { KinoticProjectConfig } from '@kinotic-ai/core'
+
+const config: KinoticProjectConfig = {
+  application: "load-testing",
+  entitiesPaths: [
+    {
+      path: "packages/domain/model",
+      repositoryPath: "packages/domain/repository",
+      mirrorFolderStructure: true
+    }
+  ],
+  fileExtensionForImports: ".js",
+  validate: false
+}
+
+export default config

package/dist/templates/spawns/project/bunup.config.ts.liquid

@@ -0,0 +1,11 @@
+import { defineWorkspace } from 'bunup'
+
+// https://bunup.dev/docs/guide/workspaces
+// You define all your packages for you {{ projectName }} here
+
+export default defineWorkspace([
+	{
+		name: 'domain',
+		root: 'packages/domain'
+	}
+])

package/dist/templates/spawns/project/package.json.liquid

@@ -0,0 +1,22 @@
+{
+    "name": "{{projectName}}",
+    "private": true,
+    "scripts": {
+        "build": "bunup",
+        "dev": "bunup --watch",
+        "type-check": "bun run --filter '*' type-check"
+    },
+    "devDependencies": {
+        "@types/bun": "^1.3.10",
+        "bunup": "^0.16.31",
+        "typescript": "^5.9.3"
+    },
+    "catalog": {
+        "@kinotic-ai/core": "{{ kinoticApiVersion }}",
+        "@kinotic-ai/persistence": "{{ kinoticApiVersion }}"
+    },
+    "workspaces": [
+        "packages/*"
+    ],
+    "type": "module"
+}

package/dist/templates/spawns/project/packages/domain/package.json.liquid

@@ -0,0 +1,34 @@
+{
+    "name": "{{ projectName }}/domain",
+    "version": "0.1.0",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "type-check": "tsc --noEmit"
+    },
+    "dependencies": {
+        "@kinotic-ai/core": "catalog:",
+        "@kinotic-ai/persistence": "catalog:"
+    },
+    "peerDependencies": {
+        "typescript": ">=4.5.0"
+    },
+    "peerDependenciesMeta": {
+        "typescript": {
+            "optional": true
+        }
+    },
+    "type": "module",
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./dist/index.d.ts",
+                "default": "./dist/index.js"
+            }
+        },
+        "./package.json": "./package.json"
+    },
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts"
+}

package/dist/templates/spawns/project/packages/domain/tsconfig.json

@@ -0,0 +1,5 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"compilerOptions": { "declaration": true, "isolatedDeclarations": true },
+	"include": ["src/**/*"]
+}

package/dist/templates/spawns/project/spawn.json

@@ -0,0 +1,11 @@
+{
+    "globals": {
+        "kinoticApiVersion": "^1.0.9"
+    },
+    "propertySchema":{
+        "projectName": {
+            "type": "string",
+            "description": "The name of the project you want to create"
+        }
+    }
+}

package/dist/templates/spawns/project/tsconfig.base.json

@@ -0,0 +1,26 @@
+{
+	"compilerOptions": {
+		"lib": ["ESNext", "DOM"],
+		"target": "ES2023",
+		"module": "Preserve",
+		"moduleDetection": "force",
+		"jsx": "react-jsx",
+
+		"moduleResolution": "bundler",
+		"allowImportingTsExtensions": true,
+		"verbatimModuleSyntax": true,
+		"noEmit": true,
+
+		"strict": true,
+		"skipLibCheck": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUncheckedIndexedAccess": true,
+		"noImplicitOverride": true,
+
+		"noUnusedLocals": false,
+		"noUnusedParameters": false,
+		"noPropertyAccessFromIndexSignature": false
+	},
+
+	"exclude": ["node_modules", "dist"]
+}

package/oclif.manifest.json

@@ -5,11 +5,12 @@
         "gen"
       ],
       "args": {},
-      "description": "This will generate all Entity Service classes.",
+      "description": "This will generate all Repository classes.",
       "examples": [
         "$ kinotic generate",
         "$ kinotic gen",
-        "$ kinotic gen -v"
+        "$ kinotic gen -v",
+        "$ kinotic gen --force"
       ],
       "flags": {
         "verbose": {
@@ -18,6 +19,13 @@
           "name": "verbose",
           "allowNo": false,
           "type": "boolean"
+        },
+        "force": {
+          "char": "f",
+          "description": "Force full regeneration, ignoring incremental change detection",
+          "name": "force",
+          "allowNo": false,
+          "type": "boolean"
         }
       },
       "hasDynamicHelp": false,
@@ -42,9 +50,10 @@
       "args": {},
       "description": "This will initialize a new Kinotic Project for use with the Kinotic CLI.",
       "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"
       ],
       "flags": {
         "application": {
@@ -65,14 +74,21 @@
           "multiple": false,
           "type": "option"
         },
-        "generated": {
-          "char": "g",
-          "description": "Path to the directory to write generated Services",
-          "name": "generated",
+        "repository": {
+          "char": "r",
+          "description": "Path to the directory to write generated Repository classes",
+          "name": "repository",
           "required": false,
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
+        },
+        "mirror": {
+          "char": "m",
+          "description": "Mirror the entity folder structure under the repository path",
+          "name": "mirror",
+          "allowNo": false,
+          "type": "boolean"
         }
       },
       "hasDynamicHelp": false,
@@ -139,6 +155,12 @@
           "name": "dryRun",
           "allowNo": false,
           "type": "boolean"
+        },
+        "force": {
+          "description": "Force full regeneration, ignoring incremental change detection",
+          "name": "force",
+          "allowNo": false,
+          "type": "boolean"
         }
       },
       "hasDynamicHelp": false,
@@ -155,7 +177,37 @@
         "commands",
         "synchronize.js"
       ]
+    },
+    "create:project": {
+      "aliases": [],
+      "args": {
+        "name": {
+          "description": "The name for the project",
+          "name": "name",
+          "required": true
+        }
+      },
+      "description": "Creates a Kinotic Project",
+      "examples": [
+        "$ kinotic create project MyProjectName"
+      ],
+      "flags": {},
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "create:project",
+      "pluginAlias": "@kinotic-ai/kinotic-cli",
+      "pluginName": "@kinotic-ai/kinotic-cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "create",
+        "project.js"
+      ]
     }
   },
-  "version": "1.0.2"
+  "version": "2.0.0"
 }