vovk-cli 0.0.1-beta.0

package/src/getProjectInfo/getCwdPath.ts

@@ -0,0 +1,15 @@
+import path from 'path';
+
+// TODO Rename
+export default function getCwdPath<T extends string | null>(inputPath: T, baseDir = process.cwd()): T {
+  if (inputPath === null) {
+    return null as T;
+  }
+  // Check if the path is absolute
+  if (path.isAbsolute(inputPath) || inputPath.startsWith('./') || inputPath.startsWith('../')) {
+    return path.resolve(baseDir, inputPath) as T;
+  }
+
+  // If it's a module or absolute path, keep it as is
+  return inputPath;
+}

package/src/getProjectInfo/getSrcRoot.ts

@@ -0,0 +1,14 @@
+import path from 'path';
+import directoryExists from './directoryExists';
+
+export default async function getSrcRoot() {
+  const cwd = process.cwd();
+  // Next.js Docs: src/app or src/pages will be ignored if app or pages are present in the root directory.
+  if (await directoryExists(path.join(cwd, 'app'))) {
+    return cwd;
+  } else if (await directoryExists(path.join(cwd, 'src/app'))) {
+    return path.join(cwd, 'src');
+  }
+
+  throw new Error(`Could not find app router directory. Check Next.js docs for more info.`);
+}

package/src/getProjectInfo/index.ts

@@ -0,0 +1,63 @@
+import type { VovkEnv } from '../types';
+import path from 'path';
+import * as loglevel from 'loglevel';
+import chalk from 'chalk';
+import getConfig from './getConfig';
+
+export type ProjectInfo = Awaited<ReturnType<typeof getProjectInfo>>;
+
+// TODO: Rename all occurrences of metadata to schema
+// TODO: Rename default API option "prefix" to "apiRoot" or just "root" (?). Also think of renaming prefix as an option to origin (?)
+// TODO: Load config dynamically to generate client and write schema
+// TODO: Create VovkCLIError class
+export default async function getProjectInfo({
+  port: givenPort,
+  clientOutDir,
+}: { port?: number; clientOutDir?: string } = {}) {
+  const env = process.env as VovkEnv;
+  const port = givenPort?.toString() ?? process.env.PORT ?? '3000';
+
+  // Make PORT available to the config file at getConfig
+  process.env.PORT = port;
+
+  const cwd = process.cwd();
+  const { config, srcRoot } = await getConfig({ clientOutDir });
+  const vovkPort = env.VOVK_PORT || (parseInt(port) + 6969).toString();
+  const apiEntryPoint = `${config.origin}/${config.rootEntry}`; // ??? TODO
+  const apiPrefix = `${config.origin}/${config.rootEntry}`; // ??? TODO
+  const apiDir = path.join(srcRoot, 'app', config.rootEntry);
+
+  const metadataOutFullPath = path.join(cwd, config.metadataOutDir);
+  const metadataOutImportPath = path.relative(config.clientOutDir, metadataOutFullPath);
+  const fetcherClientImportPath = config.fetcher.startsWith('.')
+    ? path.relative(config.clientOutDir, config.fetcher)
+    : config.fetcher;
+
+  const clientOutFullPath = path.join(cwd, config.clientOutDir);
+
+  const log = {
+    info: (msg: string) => loglevel.info(chalk.blueBright(`🐺 ${msg}`)),
+    warn: (msg: string) => loglevel.warn(chalk.yellowBright(`🐺 ${msg}`)),
+    error: (msg: string) => loglevel.error(chalk.redBright(`🐺 ${msg}`)),
+    debug: (msg: string) => loglevel.debug(chalk.gray(`🐺 ${msg}`)),
+    raw: loglevel,
+  };
+
+  loglevel.setLevel(config.logLevel);
+
+  return {
+    cwd,
+    port,
+    vovkPort,
+    apiEntryPoint,
+    apiPrefix,
+    apiDir,
+    srcRoot,
+    metadataOutFullPath,
+    metadataOutImportPath,
+    clientOutFullPath,
+    fetcherClientImportPath,
+    config,
+    log,
+  };
+}

package/src/getProjectInfo/readConfig.ts

@@ -0,0 +1,50 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import type { VovkConfig } from '../types';
+
+async function findConfigPath(): Promise<string | null> {
+  const rootDir = process.cwd();
+  const baseName = 'vovk.config';
+  const extensions = ['cjs', 'mjs', 'js'];
+
+  for (const ext of extensions) {
+    const filePath = path.join(rootDir, `${baseName}.${ext}`);
+    try {
+      await fs.stat(filePath);
+      return filePath; // Return the path if the file exists
+    } catch {
+      // If the file doesn't exist, an error is thrown. Catch it and continue checking.
+    }
+  }
+
+  return null; // Return null if no config file was found
+}
+
+async function readConfig(): Promise<VovkConfig> {
+  const configPath = await findConfigPath();
+  let config: VovkConfig = {};
+
+  if (!configPath) {
+    return config;
+  }
+
+  try {
+    if (configPath.endsWith('.cjs') || configPath.endsWith('.js')) {
+      try {
+        delete require.cache[require.resolve(configPath)];
+      } finally {
+        config = require(configPath) as VovkConfig;
+      }
+    } else if (configPath.endsWith('.mjs')) {
+      const cacheBuster = Date.now();
+      ({ default: config } = await import(`${configPath}?cache=${cacheBuster}`));
+    }
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.error('🐺 ❌ Error reading config file:', (e as Error).message);
+  }
+
+  return config;
+}
+
+export default readConfig;

package/src/index.ts

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import concurrently from 'concurrently';
+import getAvailablePort from './utils/getAvailablePort';
+import { VovkCLIServer } from './server';
+import getProjectInfo from './getProjectInfo';
+import generateClient from './server/generateClient';
+import locateSegments from './locateSegments';
+import { VovkConfig, VovkEnv } from './types';
+
+/*
+TODO:
+- Use ts-morph to update files
+- Vovk create segment <segmentName>
+- Vovk create module <segmentName>/module.ts
+- Explicit concurrently, implicit concurrently instead of "standalone" mode
+*/
+
+export type { VovkConfig, VovkEnv };
+
+interface DevOptions {
+  project: string;
+  clientOut?: string;
+  nextDev: boolean;
+}
+
+interface GenerateOptions {
+  clientOut?: string;
+}
+
+const program = new Command();
+
+program.name('vovk').description('Vovk CLI tool').version('1.0.0');
+
+program
+  .command('dev')
+  .description('Start development server (optional flag --next-dev to start Vovk Server with Next.js)')
+  .option('--project <path>', 'Path to Next.js project', process.cwd())
+  .option('--client-out <path>', 'Path to client output directory')
+  .option('--next-dev', 'Start Vovk Server and Next.js with automatic port allocation', false)
+  .allowUnknownOption(true)
+  .action(async (options: DevOptions, command: Command) => {
+    const portAttempts = 30;
+    const PORT = !options.nextDev
+      ? process.env.PORT
+      : process.env.PORT ||
+        (await getAvailablePort(3000, portAttempts, 0, (failedPort, tryingPort) =>
+          // eslint-disable-next-line no-console
+          console.warn(`🐺 Next.js Port ${failedPort} is in use, trying ${tryingPort} instead.`)
+        ).catch(() => {
+          throw new Error(`🐺 ❌ Failed to find available Next port after ${portAttempts} attempts`);
+        }));
+
+    if (!PORT) {
+      throw new Error('🐺 ❌ PORT env variable is required');
+    }
+
+    if (options.nextDev) {
+      const { result } = concurrently(
+        [
+          {
+            command: `node ${__dirname}/server/index.js`,
+            name: 'Vovk.ts Metadata Server',
+            env: Object.assign(
+              { PORT, __VOVK_START_SERVER_IN_STANDALONE_MODE__: 'true' as const },
+              options.clientOut ? { VOVK_CLIENT_OUT_DIR: options.clientOut } : {}
+            ),
+          },
+          {
+            command: `cd ${options.project} && npx next dev ${command.args.join(' ')}`,
+            name: 'Next.js Development Server',
+            env: { PORT },
+          },
+        ],
+        {
+          killOthers: ['failure', 'success'],
+          prefix: 'none',
+        }
+      );
+      try {
+        await result;
+      } finally {
+        // eslint-disable-next-line no-console
+        console.log('🐺 Exiting...');
+      }
+    } else {
+      void new VovkCLIServer().startServer({ clientOutDir: options.clientOut });
+    }
+  });
+
+program
+  .command('generate')
+  .description('Generate client')
+  .option('--client-out <path>', 'Path to output directory')
+  .action(async (options: GenerateOptions) => {
+    const projectInfo = await getProjectInfo({ clientOutDir: options.clientOut });
+    const segments = await locateSegments(projectInfo.apiDir);
+    const metadata = await import(projectInfo.metadataOutFullPath);
+
+    await generateClient(projectInfo, segments, metadata.default);
+  });
+
+program
+  .command('help')
+  .description('Show help message')
+  .action(() => program.help());
+
+program.parse(process.argv);
+
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/src/init.ts

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+/*
+npx vovk-cli init
+- Check if the project is already initialized
+  - Do you want to reinitialize the project?
+    - Yes
+    - No (exit)
+- Check for package.json, if not found, show error and exit
+- Check for tsconfig.json, if not found, show error and exit
+- Check Next.js installed
+- Choose validation library: add to the installation list
+    - vovk-zod
+        - Further installation notes: install zod
+    - vovk-yup
+        - Further installation notes: install yup
+    - vovk-dto
+        - Further installation notes: install class-validator and class-transformer
+    - None
+- If validation library is not None,
+    - Do you want to enable client validation?
+        - Yes 
+            - Add client validation to the config
+        - No
+- Do you want to use concurrently? (NO NEED, USE CONCURRENTLY BY DEFAULT)
+    - Yes (recommended)
+        - Add concurrently to the installation list
+    - No
+- Do you want to update NPM scripts?
+    - Yes
+        - Update NPM scripts
+    - No
+- if experimentalDecorators is not found in tsconfig.json,
+    - Do you want to add experimentalDecorators to tsconfig.json?
+        - Yes
+            - Add experimentalDecorators to tsconfig.json
+        - No
+- Do you want to create route file with example service and controller? (NO NEED)
+    - Yes
+        - Create route file with example controller
+    - No, I will create it myself
+- End
+    - If there are any packages to install, install them
+    - Show installation notes
+    - If there are any files to create, create
+    - If there are any config files to update, update
+    - If example route file is NOT created, show example route file and controller
+    - Show how to run the project
+        - If npm scripts are updated
+            - npm run dev
+        - If npm scripts are NOT updated
+            - If concurrently is installed
+                - concurrently "vovk dev" "next dev"
+            - If concurrently is NOT installed
+                - vovk dev --next-dev
+        - Open http://localhost:3000/api/hello-world
+        - Show how to make a request to the example route
+    - Show success message
+*/
+
+import { confirm } from '@inquirer/prompts';
+// Or
+// import confirm from '@inquirer/confirm';
+
+// eslint-disable-next-line no-console
+void confirm({ message: 'Continue?' }).then(console.info);
+
+/*
+const wizard = [
+  {
+    description: 'Check if the project is already initialized',
+    type: 'check',
+    choices: {
+      type: 'choice',
+      choices: [
+        {
+          label: 'Yes',
+          action: 'continue',
+        },
+        {
+          label: 'No',
+          action: 'exit',
+          exitMessage: 'Exiting...',
+        },
+      ],
+    },
+  },
+  {
+    description: 'Check for package.json',
+    type: 'check',
+    handleCheck: () => {
+      // Check if the project is already initialized
+    },
+    yes: {
+      action: 'continue',
+    },
+    no: {
+      action: 'exit',
+      exitMessage: 'Exiting...',
+    },
+  },
+  {
+    description: 'Check for tsconfig.json',
+    type: 'check',
+    handleCheck: () => {
+      // Check for package.json
+    },
+    yes: {
+      action: 'continue',
+    },
+    no: {
+      action: 'exit',
+      exitMessage: 'Exiting...',
+    },
+  },
+  {
+    description: 'Check Next.js installed with app router',
+    type: 'check',
+    handleCheck: () => {
+      // Check for tsconfig.json
+    },
+    yes: {
+      action: 'continue',
+    },
+    no: {
+      action: 'exit',
+      exitMessage: 'Exiting...',
+    },
+  },
+  {
+    description: 'Choose validation library',
+    type: 'install',
+    choices: {
+      type: 'choice',
+      choices: [
+        {
+          package: 'vovk-zod',
+          action: 'install',
+          notes: 'Further installation notes: install zod',
+        },
+        {
+          package: 'vovk-yup',
+          action: 'install',
+          notes: 'Further installation notes: install yup',
+        },
+        {
+          package: 'vovk-dto',
+          action: 'install',
+          notes: 'Further installation notes: install class-validator and class-transformer',
+        },
+        {
+          package: null,
+          action: 'continue',
+        },
+      ],
+    },
+  },
+  {
+    description: 'Do you want to enable client validation?',
+    type: 'choice',
+    choices: [
+      {
+        label: 'Yes',
+        action: 'updateConfig',
+      },
+      {
+        label: 'No',
+        action: 'updateConfig',
+      },
+    ],
+  },
+];
+
+// export default console.info(wizard);
+*/

package/src/locateSegments.ts

@@ -0,0 +1,40 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import fileExists from './utils/fileExists';
+
+export type Segment = {
+  routeFilePath: string;
+  segmentName: string;
+};
+
+export default async function locateSegments(dir: string, rootDir = dir): Promise<Segment[]> {
+  let results: Segment[] = [];
+
+  // Read the contents of the directory
+  const list = await fs.readdir(dir);
+
+  // Iterate through each item in the directory
+  for (const file of list) {
+    const filePath = path.join(dir, file);
+    const stat = await fs.stat(filePath);
+
+    if (stat.isDirectory()) {
+      // Check if the directory name matches the pattern [[...something]]
+      if (file.startsWith('[[...') && file.endsWith(']]')) {
+        // Check if there's a route.ts file inside this directory
+        const routeFilePath = path.join(filePath, 'route.ts');
+        if (await fileExists(routeFilePath)) {
+          // Calculate the basePath relative to the root directory
+          const segmentName = path.relative(rootDir, dir);
+          results.push({ routeFilePath, segmentName });
+        }
+      }
+
+      // Recursively search inside subdirectories
+      const subDirResults = await locateSegments(filePath, rootDir);
+      results = results.concat(subDirResults);
+    }
+  }
+
+  return results;
+}

package/src/postinstall.ts

@@ -0,0 +1,27 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+
+/**
+ * Checks if a file exists at the given path.
+ * @param {string} filePath - The path to the file.
+ * @returns {Promise<boolean>} - A promise that resolves to true if the file exists, false otherwise.
+ */
+const fileExists = async (filePath: string): Promise<boolean> => !!(await fs.stat(filePath).catch(() => false));
+
+async function postinstall(): Promise<void> {
+  const vovk = path.join(__dirname, '../../.vovk');
+  const js = path.join(vovk, 'client.js');
+  const ts = path.join(vovk, 'client.d.ts');
+  const index = path.join(vovk, 'index.ts');
+
+  if ((await fileExists(js)) || (await fileExists(ts)) || (await fileExists(index))) {
+    return;
+  }
+
+  await fs.mkdir(vovk, { recursive: true });
+  await fs.writeFile(js, '/* postinstall */');
+  await fs.writeFile(ts, '/* postinstall */');
+  await fs.writeFile(index, '/* postinstall */');
+}
+
+void postinstall();

package/src/server/createMetadataServer.ts

@@ -0,0 +1,30 @@
+import http from 'http';
+import { VovkMetadata } from 'vovk';
+
+export default function createMetadataServer(
+  then: (metadata: { metadata: VovkMetadata }) => void | Promise<void>,
+  catchFn: (err: Error) => void | Promise<void>
+) {
+  return http.createServer((req, res) => {
+    if (req.method === 'POST' && req.url === '/__metadata') {
+      let body = '';
+
+      req.on('data', (chunk) => {
+        body += chunk.toString();
+      });
+
+      req.on('end', () => {
+        try {
+          const result: { metadata: VovkMetadata } = JSON.parse(body);
+          void then(result);
+        } catch (e) {
+          void catchFn(e as Error);
+        }
+      });
+    } else {
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      res.end('Not Found');
+      void catchFn(new Error('Not Found'));
+    }
+  });
+}

package/src/server/diffMetadata.ts

@@ -0,0 +1,110 @@
+import { VovkMetadata } from 'vovk';
+import { _VovkControllerMetadata, _VovkWorkerMetadata } from 'vovk/types';
+import { isEqual } from 'lodash';
+
+interface HandlersDiff {
+  nameOfClass: string;
+  added: string[];
+  removed: string[];
+  changed: string[];
+}
+
+interface WorkersOrControllersDiff {
+  added: string[];
+  removed: string[];
+  handlers: HandlersDiff[];
+}
+
+export interface DiffResult {
+  workers: WorkersOrControllersDiff;
+  controllers: WorkersOrControllersDiff;
+}
+
+export function diffHandlers<T extends _VovkWorkerMetadata['_handlers'] | _VovkControllerMetadata['_handlers']>(
+  oldHandlers: T,
+  newHandlers: T,
+  nameOfClass: string
+): HandlersDiff {
+  const added: string[] = [];
+  const removed: string[] = [];
+  const changed: string[] = []; // Array to store changed handlers
+
+  for (const [handler, newHandler] of Object.entries(newHandlers)) {
+    if (!(handler in oldHandlers)) {
+      added.push(handler);
+    } else if (!isEqual(newHandler, oldHandlers[handler])) {
+      changed.push(handler); // Add to changed if handlers are not shallow equal
+    }
+  }
+
+  for (const [handler] of Object.entries(oldHandlers)) {
+    if (!(handler in newHandlers)) {
+      removed.push(handler);
+    }
+  }
+
+  return { nameOfClass, added, removed, changed };
+}
+
+export function diffWorkersOrControllers<T extends VovkMetadata['controllers'] | VovkMetadata['workers']>(
+  oldItems: T,
+  newItems: T
+): WorkersOrControllersDiff {
+  const added: string[] = [];
+  const removed: string[] = [];
+  const handlersDiff: HandlersDiff[] = [];
+
+  for (const [item, newItem] of Object.entries(newItems)) {
+    if (!(item in oldItems)) {
+      added.push(item);
+    } else {
+      const handlers = diffHandlers(oldItems[item]._handlers, newItem._handlers, item);
+      if (handlers.added.length || handlers.removed.length || handlers.changed.length) {
+        handlersDiff.push(handlers);
+      }
+    }
+  }
+
+  for (const [item] of Object.entries(oldItems)) {
+    if (!(item in newItems)) {
+      removed.push(item);
+    }
+  }
+
+  return { added, removed, handlers: handlersDiff };
+}
+
+/**
+example output:
+{
+  workers: {
+    added: ["WorkerC"],
+    removed: ["WorkerA"],
+    handlers: []
+  },
+  controllers: {
+    added: ["ControllerC"],
+    removed: ["ControllerB"],
+    handlers: [
+      {
+        nameOfClass: "ControllerA",
+        added: ["handlerF"],
+        removed: [],
+        changed: ["handlerD"]
+      }
+    ]
+  }
+}
+*/
+export default function diffMetadata(oldJson: VovkMetadata, newJson: VovkMetadata): DiffResult {
+  const workersDiff = diffWorkersOrControllers<VovkMetadata['workers']>(oldJson.workers ?? {}, newJson.workers ?? {});
+  const controllersDiff = diffWorkersOrControllers<VovkMetadata['controllers']>(
+    oldJson.controllers ?? {},
+    newJson.controllers ?? {}
+  );
+
+  return {
+    workers: workersDiff,
+    controllers: controllersDiff,
+  };
+}