vovk-cli 0.0.1-beta.15 → 0.0.1-beta.17

package/dist/generate/addCommonTerms.d.ts

@@ -0,0 +1 @@
+export default function addCommonTerms(): void;

package/dist/generate/addCommonTerms.js

@@ -0,0 +1,90 @@
+import pluralize from 'pluralize';
+const terms = [
+    ['entity', 'entities'],
+    ['regex', 'regexes'],
+    ['index', 'indices'],
+    ['matrix', 'matrices'],
+    ['axis', 'axes'],
+    ['schema', 'schemas'],
+    ['criterion', 'criteria'],
+    ['datum', 'data'],
+    ['formula', 'formulas'],
+    ['appendix', 'appendices'],
+    ['vertex', 'vertices'],
+    ['leaf', 'leaves'],
+    ['analysis', 'analyses'],
+    ['thesis', 'theses'],
+    ['hypothesis', 'hypotheses'],
+    ['phenomenon', 'phenomena'],
+    ['alumnus', 'alumni'],
+    ['focus', 'foci'],
+    ['medium', 'media'],
+    ['bacterium', 'bacteria'],
+    ['radius', 'radii'],
+    ['genus', 'genera'],
+    ['corpus', 'corpora'],
+    ['locus', 'loci'],
+    ['nucleus', 'nuclei'],
+    ['fungus', 'fungi'],
+    ['syllabus', 'syllabi'],
+    ['cactus', 'cacti'],
+    ['automaton', 'automata'],
+    ['stimulus', 'stimuli'],
+    ['parenthesis', 'parentheses'],
+    ['ellipsis', 'ellipses'],
+    ['diagnosis', 'diagnoses'],
+    ['oasis', 'oases'],
+    ['crisis', 'crises'],
+    ['antenna', 'antennae'],
+    ['chateau', 'chateaux'],
+    ['tableau', 'tableaux'],
+    ['penny', 'pence'],
+    ['memorandum', 'memoranda'],
+    ['erratum', 'errata'],
+    ['curriculum', 'curricula'],
+    ['millennium', 'millennia'],
+    ['stratum', 'strata'],
+    ['spectrum', 'spectra'],
+    ['apex', 'apices'],
+    ['vortex', 'vortices'],
+    ['calf', 'calves'],
+    ['loaf', 'loaves'],
+    ['foot', 'feet'],
+    ['tooth', 'teeth'],
+    ['mouse', 'mice'],
+    ['goose', 'geese'],
+    ['child', 'children'],
+    ['person', 'people'],
+    ['man', 'men'],
+    ['woman', 'women'],
+    ['ox', 'oxen'],
+    ['die', 'dice'],
+    ['brother', 'brethren'],
+    ['stimulus', 'stimuli'],
+    ['larva', 'larvae'],
+    ['nebula', 'nebulae'],
+    ['formula', 'formulae'],
+    ['antenna', 'antennas'],
+    ['vertebra', 'vertebrae'],
+    ['index', 'indexes'],
+    ['addendum', 'addenda'],
+    ['aquarium', 'aquaria'],
+    ['stadium', 'stadia'],
+    ['maximum', 'maxima'],
+    ['minimum', 'minima'],
+    ['referendum', 'referenda'],
+    ['forum', 'fora'],
+    ['schema', 'schemata'],
+    ['leaf', 'leaves'],
+    ['knife', 'knives'],
+    ['wolf', 'wolves'],
+    ['elf', 'elves'],
+    ['half', 'halves'],
+    ['scarf', 'scarves'],
+];
+export default function addCommonTerms() {
+    terms.forEach(([singular, plural]) => {
+        const regex = new RegExp(`${singular}$`, 'i');
+        pluralize.addPluralRule(regex, plural);
+    });
+}

package/dist/generate/replaceOccurrences.d.mts

@@ -0,0 +1 @@
+export default function replaceOccurrences(code: string, replacementSingular: string): string;

package/dist/generate/replaceOccurrences.mjs

@@ -0,0 +1,49 @@
+import camelCase from 'lodash/camelCase.js';
+import kebabCase from 'lodash/kebabCase.js';
+import snakeCase from 'lodash/snakeCase.js';
+import upperFirst from 'lodash/upperFirst.js';
+import pluralize from 'pluralize';
+import addCommonTerms from './addCommonTerms';
+addCommonTerms();
+console.log('WoRD', pluralize('entity'));
+export default function replaceOccurrences(code, replacementSingular) {
+    const replacementPlural = pluralize(replacementSingular);
+    // Different cases of the replacement string
+    const replacements = {
+        camelPlural: camelCase(replacementPlural),
+        camel: camelCase(replacementSingular),
+        pascalPlural: upperFirst(camelCase(replacementPlural)),
+        pascal: upperFirst(camelCase(replacementSingular)),
+        kebabPlural: kebabCase(replacementPlural),
+        kebab: kebabCase(replacementSingular),
+        snakePlural: snakeCase(replacementPlural),
+        snake: snakeCase(replacementSingular),
+        screamingSnakePlural: snakeCase(replacementPlural).toUpperCase(),
+        screamingSnake: snakeCase(replacementSingular).toUpperCase(),
+        screamingKebabPlural: kebabCase(replacementPlural).toUpperCase(),
+        screamingKebab: kebabCase(replacementSingular).toUpperCase(),
+    };
+    // Create a map of original patterns to their replacements
+    const originalPatterns = {
+        camelPlural: 'myThings',
+        camel: 'myThing',
+        pascalPlural: 'MyThings',
+        pascal: 'MyThing',
+        kebabPlural: 'my-things',
+        kebab: 'my-thing',
+        snakePlural: 'my_things',
+        snake: 'my_thing',
+        screamingSnakePlural: 'MY_THINGS',
+        screamingSnake: 'MY_THING',
+        screamingKebabPlural: 'MY-THINGS',
+        screamingKebab: 'MY-THING',
+    };
+    // Replace all occurrences in the code
+    Object.keys(originalPatterns).forEach((key) => {
+        const pattern = originalPatterns[key];
+        const replacementValue = replacements[key];
+        const regex = new RegExp(pattern, 'g');
+        code = code.replace(regex, replacementValue);
+    });
+    return code;
+}

package/dist/generateClient.mjs

@@ -81,7 +81,7 @@ const prefix = '${projectInfo.apiEntryPoint}';
     const existingDts = await fs.readFile(localDtsPath, 'utf-8').catch(() => '');
     const existingTs = await fs.readFile(localTsPath, 'utf-8').catch(() => '');
     if (existingJs === js && existingDts === dts && existingTs === ts) {
-        projectInfo.log.info(`Client is up to date and doesn't need to be regenerated (${Date.now() - now}ms).`);
+        projectInfo.log.info(`Client is up to date and doesn't need to be regenerated (${Date.now() - now}ms)`);
         return { written: false, path: clientoOutDirFullPath };
     }
     await fs.mkdir(clientoOutDirFullPath, { recursive: true });

package/dist/getProjectInfo/getConfig.mjs

@@ -10,7 +10,7 @@ export default async function getConfig({ clientOutDir }) {
         validationLibrary: env.VOVK_VALIDATION_LIBRARY ?? userConfig.validationLibrary ?? null,
         fetcher: env.VOVK_FETCHER ?? userConfig.fetcher ?? 'vovk/client/defaultFetcher',
         schemaOutDir: env.VOVK_SCHEMA_OUT_DIR ?? userConfig.schemaOutDir ?? './.vovk-schema',
-        clientOutDir: clientOutDir ?? env.VOVK_CLIENT_OUT_DIR ?? userConfig.clientOutDir ?? './node_modules/.vovk',
+        clientOutDir: clientOutDir ?? env.VOVK_CLIENT_OUT_DIR ?? userConfig.clientOutDir ?? './node_modules/.vovk-client',
         origin: (env.VOVK_ORIGIN ?? userConfig.origin ?? '').replace(/\/$/, ''), // Remove trailing slash
         rootEntry: env.VOVK_ROOT_ENTRY ?? userConfig.rootEntry ?? 'api',
         rootSegmentModulesDirName: env.VOVK_ROOT_SEGMENT_MODULES_DIR_NAME ?? userConfig.rootSegmentModulesDirName ?? '',

package/dist/index.mjs

@@ -51,8 +51,7 @@ program
             await result;
         }
         finally {
-            // eslint-disable-next-line no-console
-            console.log('🐺 Exiting...');
+            // do nothing, all processes are killed
         }
     }
     else {

package/dist/utils/chalkHighlightThing.d.mts

@@ -0,0 +1 @@
+export default function chalkHighlightThing(str: string): string;

package/dist/utils/chalkHighlightThing.mjs

@@ -0,0 +1,4 @@
+import chalk from 'chalk';
+export default function chalkHighlightThing(str) {
+    return chalk.cyan.bold(str);
+}

package/dist/utils/formatLoggedSegmentName.mjs

@@ -1,5 +1,5 @@
-import chalk from 'chalk';
+import chalkHighlightThing from './chalkHighlightThing.mjs';
 export default function formatLoggedSegmentName(segmentName, withChalk = false) {
     const text = segmentName ? `segment "${segmentName}"` : 'the root segment';
-    return withChalk ? chalk.white.bold(text) : text;
+    return withChalk ? chalkHighlightThing(text) : text;
 }

package/dist/utils/getLogger.mjs

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 import loglevel from 'loglevel';
 export default function getLogger(level) {
     const log = {
-        info: (msg) => loglevel.info(chalk.cyanBright(`🐺 ${msg}`)),
+        info: (msg) => loglevel.info(chalk.white(`🐺 ${msg}`)),
         warn: (msg) => loglevel.warn(chalk.yellowBright(`🐺 ${msg}`)),
         error: (msg) => loglevel.error(chalk.redBright(`🐺 ${msg}`)),
         debug: (msg) => loglevel.debug(chalk.gray(`🐺 ${msg}`)),

package/dist/watcher/index.mjs

@@ -11,6 +11,8 @@ import debounceWithArgs from '../utils/debounceWithArgs.mjs';
 import debounce from 'lodash/debounce.js';
 import isEmpty from 'lodash/isEmpty.js';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
+import keyBy from 'lodash/keyBy.js';
+import { capitalize } from 'lodash';
 export class VovkCLIWatcher {
     #projectInfo;
     #segments = [];
@@ -37,7 +39,7 @@ export class VovkCLIWatcher {
                 this.#segments = this.#segments.find((s) => s.segmentName === segmentName)
                     ? this.#segments
                     : [...this.#segments, { routeFilePath: filePath, segmentName }];
-                log.info(`Segment "${segmentName}" has been added`);
+                log.info(`${capitalize(formatLoggedSegmentName(segmentName, true))} has been added`);
                 log.debug(`Full list of segments: ${this.#segments.map((s) => s.segmentName).join(', ')}`);
                 void debouncedEnsureSchemaFiles(schemaOutFullPath, this.#segments.map((s) => s.segmentName), this.#projectInfo // TODO refactor
                 );
@@ -70,7 +72,7 @@ export class VovkCLIWatcher {
             if (segmentReg.test(filePath)) {
                 const segmentName = getSegmentName(filePath);
                 this.#segments = this.#segments.filter((s) => s.segmentName !== segmentName);
-                log.info(`Segment "${segmentName}" has been removed`);
+                log.info(`${capitalize(formatLoggedSegmentName(segmentName, true))} has been removed`);
                 log.debug(`Full list of segments: ${this.#segments.map((s) => s.segmentName).join(', ')}`);
                 void debouncedEnsureSchemaFiles(schemaOutFullPath, this.#segments.map((s) => s.segmentName), this.#projectInfo // TODO refactor
                 );
@@ -167,13 +169,18 @@ export class VovkCLIWatcher {
             return;
         const nameOfClasReg = /\bclass\s+([A-Za-z_]\w*)(?:\s*<[^>]*>)?\s*\{/g;
         const namesOfClasses = [...code.matchAll(nameOfClasReg)].map((match) => match[1]);
-        const importRegex = /import\s*{[^}]*\b(initVovk|get|post|put|del|head|options|worker)\b[^}]*}\s*from\s*['"]vovk['"]/;
+        const importRegex = /import\s*{[^}]*\b(get|post|put|del|head|options|worker)\b[^}]*}\s*from\s*['"]vovk['"]/;
         if (importRegex.test(code) && namesOfClasses.length) {
             const affectedSegments = this.#segments.filter((s) => {
                 const schema = this.#schemas[s.segmentName];
                 if (!schema)
                     return false;
-                return namesOfClasses.some((name) => schema.controllers[name] || schema.workers[name]);
+                const controllersByOriginalName = keyBy(schema.controllers, '_originalControllerName');
+                const workersByOriginalName = keyBy(schema.workers, '_originalWorkerName');
+                return namesOfClasses.some((name) => schema.controllers[name] ||
+                    schema.workers[name] ||
+                    controllersByOriginalName[name] ||
+                    workersByOriginalName[name]);
             });
             if (affectedSegments.length) {
                 log.debug(`A file with controller or worker ${namesOfClasses.join(', ')} have been modified at path "${filePath}". Segment(s) affected: ${affectedSegments.map((s) => s.segmentName).join(', ')}`);
@@ -232,7 +239,7 @@ export class VovkCLIWatcher {
             log.error(`Non-empty schema provided for ${formatLoggedSegmentName(segment.segmentName, true)} but emitSchema is false`);
         }
         if (this.#segments.every((s) => this.#schemas[s.segmentName])) {
-            log.debug(`All segments with emitSchema=true have schema.`);
+            log.debug(`All segments with "emitSchema" have schema.`);
             await generateClient(this.#projectInfo, this.#segments, this.#schemas);
         }
     }

package/dist/watcher/logDiffResult.mjs

@@ -1,5 +1,5 @@
-import chalk from 'chalk';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
+import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 export default function logDiffResult(segmentName, diffResult, projectInfo) {
     const diffNormalized = [];
     diffResult.workers.added.forEach((name) => {
@@ -31,43 +31,43 @@ export default function logDiffResult(segmentName, diffResult, projectInfo) {
             case 'worker':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for worker ${chalk.white.bold(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName, true)}`);
+                        projectInfo.log.info(`Schema for worker ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName, true)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for worker ${chalk.white.bold(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName, true)}`);
+                        projectInfo.log.info(`Schema for worker ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName, true)}`);
                         break;
                 }
                 break;
             case 'controller':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for controller ${chalk.white.bold(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName, true)}`);
+                        projectInfo.log.info(`Schema for controller ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName, true)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for controller ${chalk.white.bold(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName, true)}`);
+                        projectInfo.log.info(`Schema for controller ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName, true)}`);
                         break;
                 }
                 break;
             case 'workerHandler':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for worker method ${chalk.white.bold(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName, true)}`);
+                        projectInfo.log.info(`Schema for worker method ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName, true)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for worker method ${chalk.white.bold(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName, true)}`);
+                        projectInfo.log.info(`Schema for worker method ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName, true)}`);
                         break;
                 }
                 break;
             case 'controllerHandler':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for controller method ${chalk.white.bold(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName, true)}`);
+                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName, true)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for controller method ${chalk.white.bold(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName, true)}`);
+                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName, true)}`);
                         break;
                     case 'changed':
-                        projectInfo.log.info(`Schema for controller method ${chalk.white.bold(diffNormalizedItem.name)} has been changed at ${formatLoggedSegmentName(segmentName, true)}`);
+                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been changed at ${formatLoggedSegmentName(segmentName, true)}`);
                         break;
                 }
                 break;

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-beta.15",
+  "version": "0.0.1-beta.17",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
+  "main": "./dist/index.mjs",
   "type": "module",
   "types": "./dist/index.d.mts",
   "prefix": ".",
   "scripts": {
-    "build": "rm -rf dist tsconfig.tsbuildinfo && tsc",
-    "test": "ts-node test/index.mts",
+    "build": "rm -rf dist tsconfig.build.tsbuildinfo && tsc -P tsconfig.build.json",
+    "test": "NODE_OPTIONS=\"--loader ts-node/esm\" TS_NODE_PROJECT=./tsconfig.test.json node test/index.mts",
     "ncu": "npm-check-updates -u",
     "npm-publish": "npm publish"
   },
@@ -30,21 +31,24 @@
   },
   "homepage": "https://vovk.dev",
   "peerDependencies": {
-    "vovk": "^3.0.0-beta.22"
+    "vovk": "^3.0.0-beta.29"
   },
   "dependencies": {
-    "@inquirer/prompts": "^5.3.8",
+    "@inquirer/prompts": "^5.5.0",
     "@npmcli/package-json": "^5.2.0",
     "chalk": "^5.3.0",
     "chokidar": "^3.6.0",
     "commander": "^12.1.0",
     "concurrently": "^8.2.2",
+    "inflection": "^3.0.0",
     "jsonc-parser": "^3.3.1",
     "lodash": "^4.17.21",
-    "loglevel": "^1.9.1"
+    "loglevel": "^1.9.2",
+    "pluralize": "^8.0.0"
   },
   "devDependencies": {
     "@types/npmcli__package-json": "^4.0.4",
+    "@types/pluralize": "^0.0.33",
     "type-fest": "^4.26.0"
   }
 }

package/templates/MyThingController.c.only.template.ts

@@ -0,0 +1,32 @@
+import { prefix, get, put, post, del, type VovkRequest } from 'vovk';
+
+@prefix('my-things')
+export default class MyThingController {
+  @get()
+  static getMyThingsExample = (req: VovkRequest<null, { q: string }>) => {
+    const q = req.nextUrl.searchParams.get('q');
+    return { q };
+  };
+
+  @put(':id')
+  static updateMyThingExample = async (
+    req: VovkRequest<{ foo: 'bar' | 'baz' }, { q: string }>,
+    params: { id: string }
+  ) => {
+    const { id } = params;
+    const body = await req.json();
+    const q = req.nextUrl.searchParams.get('q');
+
+    return { id, q, body };
+  };
+
+  @post()
+  static createMyThingExample = () => {
+    // ...
+  };
+
+  @del(':id')
+  static deleteMyThingExample = () => {
+    // ...
+  };
+}

package/templates/MyThingController.c.template.ts

@@ -0,0 +1,34 @@
+import { prefix, get, put, post, del, type VovkRequest } from 'vovk';
+import MyThingService from './MyThingService.s.template';
+
+@prefix('my-things')
+export default class MyThingController {
+  @get()
+  static getMyThingsExample(req: VovkRequest<null, { q: string }>) {
+    const q = req.nextUrl.searchParams.get('q');
+
+    return MyThingService.getMyThingsExample(q);
+  }
+
+  @put(':id')
+  static updateMyThingExample = async (
+    req: VovkRequest<{ foo: 'bar' | 'baz' }, { q: string }>,
+    params: { id: string }
+  ) => {
+    const { id } = params;
+    const body = await req.json();
+    const q = req.nextUrl.searchParams.get('q');
+
+    return MyThingService.updateMyThingExample(id, q, body);
+  };
+
+  @post()
+  static createMyThingExample = () => {
+    // ...
+  };
+
+  @del(':id')
+  static deleteMyThingExample = () => {
+    // ...
+  };
+}

package/templates/MyThingService.s.template.ts

@@ -0,0 +1,18 @@
+import type { VovkControllerBody, VovkControllerQuery } from 'vovk';
+import type MyThingController from './MyThingController.c.template';
+
+export default class MyThingService {
+  static getMyThingsExample = (q: VovkControllerQuery<typeof MyThingController.getMyThingsExample>['q']) => {
+    return { q };
+  };
+
+  static updateMyThingExample = (
+    id: string,
+    q: VovkControllerQuery<typeof MyThingController.updateMyThingExample>['q'],
+    body: VovkControllerBody<typeof MyThingController.updateMyThingExample>
+  ) => {
+    return { id, q, body };
+  };
+
+  // ...
+}