vovk-cli 0.0.1-draft.165 → 0.0.1-draft.166

package/dist/getProjectInfo/index.d.mts

@@ -1,16 +1,15 @@
-import type { BundleOptions, GenerateOptions } from '../types.mjs';
 export type ProjectInfo = Awaited<ReturnType<typeof getProjectInfo>>;
-export default function getProjectInfo({ port: givenPort, cwd, cliGenerateOptions, cliBundleOptions, }?: {
+export default function getProjectInfo({ port: givenPort, cwd, configPath, srcRootRequired, }?: {
     port?: number;
     cwd?: string;
-    cliGenerateOptions?: GenerateOptions;
-    cliBundleOptions?: BundleOptions;
+    configPath?: string;
+    srcRootRequired?: boolean;
 }): Promise<{
     cwd: string;
     port: string;
     apiRoot: string;
     apiDir: string;
-    srcRoot: string;
+    srcRoot: string | null;
     config: import("vovk").VovkStrictConfig;
     log: {
         info: (msg: string) => void;
@@ -19,5 +18,4 @@ export default function getProjectInfo({ port: givenPort, cwd, cliGenerateOption
         debug: (msg: string) => void;
         raw: import("loglevel").RootLogger;
     };
-    segments: import("../locateSegments.mjs").Segment[];
 }>;

package/dist/getProjectInfo/index.mjs

@@ -1,25 +1,21 @@
 import path from 'node:path';
 import getConfig from './getConfig/index.mjs';
-import locateSegments from '../locateSegments.mjs';
-export default async function getProjectInfo({ port: givenPort, cwd = process.cwd(), cliGenerateOptions, cliBundleOptions, } = {}) {
+export default async function getProjectInfo({ port: givenPort, cwd = process.cwd(), configPath, srcRootRequired = true, } = {}) {
     const port = givenPort?.toString() ?? process.env.PORT ?? '3000';
     // Make PORT available to the config file at getConfig
     process.env.PORT = port;
-    const { config, srcRoot, configAbsolutePaths, userConfig, error, log } = await getConfig({
-        cliGenerateOptions,
-        cliBundleOptions,
+    const { config, srcRoot, configAbsolutePaths, log } = await getConfig({
+        configPath,
         cwd,
     });
+    if (srcRootRequired && !srcRoot) {
+        throw new Error(`Could not find app router directory at ${cwd}. Check Next.js docs for more info.`);
+    }
     const apiRoot = `${config.origin ?? ''}/${config.rootEntry}`;
-    const apiDir = path.join(srcRoot, 'app', config.rootEntry);
+    const apiDir = path.join(srcRoot ?? '.', 'app', config.rootEntry);
     if (configAbsolutePaths.length > 1) {
         log.warn(`Multiple config files found. Using the first one: ${configAbsolutePaths[0]}`);
     }
-    if (!userConfig && configAbsolutePaths.length > 0) {
-        log.error(`Error reading config file at ${configAbsolutePaths[0]}: ${error?.message ?? 'Unknown Error'}`);
-    }
-    const apiDirAbsolutePath = path.join(cwd, apiDir);
-    const segments = await locateSegments({ dir: apiDirAbsolutePath, config, log });
     return {
         cwd,
         port,
@@ -28,6 +24,5 @@ export default async function getProjectInfo({ port: givenPort, cwd = process.cw
         srcRoot,
         config,
         log,
-        segments,
     };
 }

package/dist/index.mjs

@@ -12,6 +12,7 @@ import { VovkDev } from './dev/index.mjs';
 import newComponents from './new/index.mjs';
 import initProgram from './initProgram.mjs';
 import { getFullSchemaFromJSON } from './generate/getFullSchemaFromJSON.mjs';
+import locateSegments from './locateSegments.mjs';
 const program = new Command();
 const packageJSON = JSON.parse(readFileSync(path.join(import.meta.dirname, '../package.json'), 'utf-8'));
 program.name('vovk').description('Vovk CLI').version(packageJSON.version);
@@ -73,24 +74,30 @@ program
     .command('generate')
     .alias('g')
     .description('Generate RPC client from schema')
-    .option('--out, --full-out <path>', 'path to output directory for full client')
-    .option('--from, --full-from <templates...>', 'client template names for full client')
-    .option('--full-only', 'generate only full client')
-    .option('--segmented-only', 'generate only segmented client')
+    .option('--out, --composed-out <path>', 'path to output directory for composed client')
+    .option('--from, --composed-from <templates...>', 'client template names for composed client')
+    .option('--include, --composed-include-segments <segments...>', 'include segments in composed client')
+    .option('--exclude, --composed-exclude-segments <segments...>', 'exclude segments in composed client')
+    .option('--composed-only', 'generate only composed client even if segmented client is enabled')
+    .option('--segmented-only', 'generate only segmented client even if composed client is enabled')
     .option('--segmented-out <path>', 'path to output directory for segmented client')
     .option('--segmented-from <templates...>', 'client template names for segmented client')
+    .option('--segmented-include-segments <segments...>', 'include segments in segmented client')
+    .option('--segmented-exclude-segments <segments...>', 'exclude segments in segmented client')
     .option('--prettify', 'prettify output files')
     .option('--config <config>', 'path to config file')
     .action(async (cliGenerateOptions) => {
-    const projectInfo = await getProjectInfo({ cliGenerateOptions });
-    const { cwd, config } = projectInfo;
+    const projectInfo = await getProjectInfo({ configPath: cliGenerateOptions.config, srcRootRequired: false });
+    const { cwd, config, log, apiDir } = projectInfo;
+    const locatedSegments = await locateSegments({ dir: path.join(cwd, apiDir), config, log });
     const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
-    const fullSchema = await getFullSchemaFromJSON(schemaOutAbsolutePath, projectInfo);
+    const fullSchema = await getFullSchemaFromJSON(schemaOutAbsolutePath, log);
     await generate({
         projectInfo,
         fullSchema,
         forceNothingWrittenLog: true,
         cliGenerateOptions,
+        locatedSegments,
     });
 });
 program
@@ -98,20 +105,20 @@ program
     .alias('b')
     .description('Generate TypeScrtipt RPC and bundle it')
     .option('--out, --out-dir <path>', 'path to output directory for bundle')
+    .option('--include, --include-segments <segments...>', 'include segments')
+    .option('--exclude, --exclude-segments <segments...>', 'exclude segments')
     .option('--ts-client-out-dir <path>', 'path to output directory for TypeScript client')
-    .option('--no-readme', 'do not generate README file')
-    .option('--no-package', 'do not generate package.json file')
     .option('--dont-delete-ts-client-out-dir-after', 'do not delete TypeScript client output directory after bundling')
     .option('--config <config>', 'path to config file')
     .option('--sourcemap', 'generate sourcemaps')
     .action(async (cliBundleOptions) => {
-    const projectInfo = await getProjectInfo({ cliBundleOptions });
-    const { cwd, config } = projectInfo;
-    const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
-    const fullSchema = await getFullSchemaFromJSON(schemaOutAbsolutePath, projectInfo);
+    const projectInfo = await getProjectInfo({ configPath: cliBundleOptions.config, srcRootRequired: false });
+    const { cwd, config, log } = projectInfo;
+    const fullSchema = await getFullSchemaFromJSON(path.resolve(cwd, config.schemaOutDir), log);
     await bundle({
         projectInfo,
         fullSchema,
+        cliBundleOptions,
     });
 });
 program

package/dist/init/index.mjs

@@ -1,7 +1,7 @@
 import { confirm, select } from '@inquirer/prompts';
 import path from 'node:path';
 import fs from 'node:fs/promises';
-import getConfigPaths from '../getProjectInfo/getConfigAbsolutePaths.mjs';
+import getConfigPaths from '../getProjectInfo/getConfig/getConfigAbsolutePaths.mjs';
 import chalk from 'chalk';
 import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
 import installDependencies, { getPackageManager } from './installDependencies.mjs';

package/dist/new/newModule.mjs

@@ -8,6 +8,7 @@ import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
 import prettify from '../utils/prettify.mjs';
 import resolveAbsoluteModulePath from '../utils/resolveAbsoluteModulePath.mjs';
+import locateSegments from '../locateSegments.mjs';
 function splitByLast(str, delimiter = '/') {
     const index = str.lastIndexOf(delimiter);
     if (index === -1) {
@@ -19,7 +20,8 @@ function splitByLast(str, delimiter = '/') {
     return [before, after];
 }
 export default async function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }) {
-    const { config, log, cwd, segments } = await getProjectInfo();
+    const { config, log, cwd, apiDir } = await getProjectInfo();
+    const segments = await locateSegments({ dir: path.join(cwd, apiDir), config, log });
     let templates = config.moduleTemplates;
     const [segmentName, moduleName] = splitByLast(moduleNameWithOptionalSegment);
     // replace c by controller, s by service, everything else keeps the same

package/dist/new/newSegment.mjs

@@ -7,7 +7,7 @@ import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import prettify from '../utils/prettify.mjs';
 import chalk from 'chalk';
 export default async function newSegment({ segmentName, isStaticSegment, overwrite, dryRun, }) {
-    const { apiDir, cwd, log } = await getProjectInfo();
+    const { apiDir, cwd, log, config } = await getProjectInfo();
     const absoluteSegmentRoutePath = path.join(cwd, apiDir, segmentName, '[[...vovk]]/route.ts');
     if (!overwrite && (await getFileSystemEntryType(absoluteSegmentRoutePath))) {
         throw new Error(`Unable to create new segment. ${formatLoggedSegmentName(segmentName, { upperFirst: true })} already exists.`);
@@ -20,9 +20,11 @@ const controllers = {};
 
 export type Controllers = typeof controllers;
 ${isStaticSegment
-        ? `export function generateStaticParams() {
+        ? `
+export function generateStaticParams() {
   return generateStaticAPI(controllers);
-}`
+}
+`
         : ''}
 export const { GET${isStaticSegment ? '' : ', POST, PATCH, PUT, HEAD, OPTIONS, DELETE'} } = initVovk({
 ${segmentName ? `  segmentName: '${segmentName}',\n` : ''}  emitSchema: true,
@@ -33,7 +35,7 @@ ${segmentName ? `  segmentName: '${segmentName}',\n` : ''}  emitSchema: true,
         await fs.mkdir(path.dirname(absoluteSegmentRoutePath), { recursive: true });
         await fs.writeFile(absoluteSegmentRoutePath, code);
     }
-    log.info(`${formatLoggedSegmentName(segmentName, { upperFirst: true })} created at ${absoluteSegmentRoutePath}.`);
+    log.info(`${formatLoggedSegmentName(segmentName, { upperFirst: true, isStatic: isStaticSegment })} created at ${absoluteSegmentRoutePath}.`);
     const dir = chalk.cyanBright([segmentName, 'thing'].filter(Boolean).join('/'));
-    log.info(`Run ${chalkHighlightThing(`npx vovk new service controller ${dir}`)} to create a new controller with a service at modules/${dir} folder for this segment`);
+    log.info(`Run ${chalkHighlightThing(`npx vovk new service controller ${dir}`)} to create a new controller with a service at ${path.join(config.modulesDir, dir)} folder for this segment`);
 }

package/dist/types.d.mts

@@ -14,12 +14,16 @@ export interface DevOptions {
 export interface GenerateOptions {
     prettify?: boolean;
     config?: string;
-    fullFrom?: string[];
-    fullOut?: string;
-    fullOnly?: boolean;
+    composedFrom?: string[];
+    composedOut?: string;
+    composedOnly?: boolean;
+    composedIncludeSegments?: string[];
+    composedExcludeSegments?: string[];
     segmentedFrom?: string[];
     segmentedOut?: string;
     segmentedOnly?: boolean;
+    segmentedIncludeSegments?: string[];
+    segmentedExcludeSegments?: string[];
 }
 export interface BundleOptions extends Partial<Omit<VovkStrictConfig['bundle'], 'requires'>> {
     config?: string;
@@ -51,14 +55,9 @@ export interface NewOptions {
 export type VovkEnv = {
     PORT?: string;
     VOVK_SCHEMA_OUT_DIR?: string;
-    VOVK_IMPORTS_FETCHER?: string;
-    VOVK_IMPORTS_VALIDATE_ON_CLIENT?: string;
-    VOVK_IMPORTS_CREATE_RPC?: string;
-    VOVK_MODULES_DIR?: string;
     VOVK_ORIGIN?: string;
     VOVK_ROOT_ENTRY?: string;
     VOVK_API_ENTRY_POINT?: string;
-    VOVK_ROOT_SEGMENT_MODULES_DIR_NAME?: string;
     VOVK_LOG_LEVEL?: LogLevelNames;
     VOVK_PRETTIFY_CLIENT?: string;
     VOVK_DEV_HTTPS?: string;

package/dist/utils/formatLoggedSegmentName.d.mts

@@ -1,4 +1,5 @@
-export default function formatLoggedSegmentName(segmentName: string, { withChalk, upperFirst }?: {
+export default function formatLoggedSegmentName(segmentName: string, { withChalk, upperFirst, isStatic, }?: {
     withChalk?: boolean;
     upperFirst?: boolean;
+    isStatic?: boolean;
 }): string;

package/dist/utils/formatLoggedSegmentName.mjs

@@ -1,7 +1,7 @@
 import upperFirstLodash from 'lodash/upperFirst.js';
 import chalkHighlightThing from './chalkHighlightThing.mjs';
-export default function formatLoggedSegmentName(segmentName, { withChalk = true, upperFirst = false } = {}) {
-    let text = segmentName ? `segment "${segmentName}"` : 'the root segment';
+export default function formatLoggedSegmentName(segmentName, { withChalk = true, upperFirst = false, isStatic = false, } = {}) {
+    let text = segmentName ? `${isStatic ? 'static ' : ''}segment "${segmentName}"` : 'the root segment';
     text = upperFirst ? upperFirstLodash(text) : text;
     return withChalk ? chalkHighlightThing(text) : text;
 }

package/dist/utils/getPublicModuleNameFromPath.d.mts

@@ -0,0 +1,4 @@
+export default function getPublicModuleNameFromPath(modulePath: string): {
+    moduleName: string | null;
+    restPath: string;
+};

package/dist/utils/getPublicModuleNameFromPath.mjs

@@ -0,0 +1,9 @@
+export default function getPublicModuleNameFromPath(modulePath) {
+    if (modulePath && !modulePath.startsWith('.') && !modulePath.startsWith('/')) {
+        const pathParts = modulePath.split('/');
+        const moduleName = pathParts[0].startsWith('@') ? `${pathParts[0]}/${pathParts[1]}` : pathParts[0];
+        const restPath = pathParts.slice(pathParts[0].startsWith('@') ? 2 : 1).join('/');
+        return { moduleName, restPath };
+    }
+    return { moduleName: null, restPath: modulePath };
+}

package/dist/utils/pickSegmentFullSchema.d.mts

@@ -1,3 +1,3 @@
-import type { VovkFullSchema } from 'vovk';
-export default function pickSegmentFullSchema(fullSchema: VovkFullSchema, segmentNames: string[]): VovkFullSchema;
-export declare function omitSegmentFullSchema(fullSchema: VovkFullSchema, segmentNames: string[]): VovkFullSchema;
+import { type VovkSchema } from 'vovk';
+export default function pickSegmentFullSchema(schema: VovkSchema, segmentNames: string[]): VovkSchema;
+export declare function omitSegmentFullSchema(schema: VovkSchema, segmentNames: string[]): VovkSchema;

package/dist/utils/pickSegmentFullSchema.mjs

@@ -1,17 +1,15 @@
-import { SchemaIdEnum } from '../enums.mjs';
-export default function pickSegmentFullSchema(fullSchema, segmentNames) {
+import { VovkSchemaIdEnum } from 'vovk';
+export default function pickSegmentFullSchema(schema, segmentNames) {
     return {
-        $schema: SchemaIdEnum.FULL,
-        config: fullSchema.config,
-        segments: {
-            ...Object.fromEntries(segmentNames.map((segmentName) => [segmentName, fullSchema.segments[segmentName]])),
-        },
+        $schema: VovkSchemaIdEnum.SCHEMA,
+        config: schema.config,
+        segments: Object.fromEntries(segmentNames.map((segmentName) => [segmentName, schema.segments[segmentName]])),
     };
 }
-export function omitSegmentFullSchema(fullSchema, segmentNames) {
+export function omitSegmentFullSchema(schema, segmentNames) {
     return {
-        $schema: SchemaIdEnum.FULL,
-        config: fullSchema.config,
-        segments: Object.fromEntries(Object.entries(fullSchema.segments).filter(([segmentName]) => !segmentNames.includes(segmentName))),
+        $schema: VovkSchemaIdEnum.SCHEMA,
+        config: schema.config,
+        segments: Object.fromEntries(Object.entries(schema.segments).filter(([segmentName]) => !segmentNames.includes(segmentName))),
     };
 }

package/dist/utils/resolveAbsoluteModulePath.d.mts

@@ -1 +1,2 @@
+export declare function getPathUpToModule(moduleName: string, fullPath: string): string;
 export default function resolveAbsoluteModulePath(modulePath: string, cwd: string): string;

package/dist/utils/resolveAbsoluteModulePath.mjs

@@ -1,5 +1,13 @@
 import path from 'node:path';
 import { createRequire } from 'node:module';
+import getPublicModuleNameFromPath from './getPublicModuleNameFromPath.mjs';
+// Returns the path up to and including the last occurrence of the given module name
+export function getPathUpToModule(moduleName, fullPath) {
+    const idx = fullPath.lastIndexOf(moduleName);
+    if (idx === -1)
+        return moduleName;
+    return fullPath.slice(0, idx + moduleName.length);
+}
 export default function resolveAbsoluteModulePath(modulePath, cwd) {
     // If it's an absolute path or starts with '.' (relative), resolve it directly
     if (modulePath.startsWith('/') || modulePath.startsWith('.')) {
@@ -7,12 +15,16 @@ export default function resolveAbsoluteModulePath(modulePath, cwd) {
     }
     // For npm package names, use Node's module resolution algorithm
     try {
-        // Create a require function based on the cwd
-        // We don't need an actual file, just a path within the directory to create the context
-        const require = createRequire(path.join(cwd, 'package.json'));
-        return require.resolve(modulePath);
+        const { moduleName, restPath } = getPublicModuleNameFromPath(modulePath);
+        if (!moduleName) {
+            throw new Error(`Invalid module path: ${modulePath}`);
+        }
+        const require = createRequire(import.meta.url);
+        const resolved = require.resolve(moduleName);
+        return path.resolve(getPathUpToModule(moduleName, path.dirname(resolved)), restPath);
     }
-    catch {
+    catch (e) {
+        console.error(`Error resolving module path: ${modulePath}`, e);
         // If resolution fails, fall back to the original behavior
         return path.resolve(cwd, './node_modules', modulePath);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.165",
+  "version": "0.0.1-draft.166",
   "bin": {
     "vovk": "./dist/index.mjs"
   },

package/client-templates/fullSchemaCjs/fullSchema.d.cts.ejs

@@ -1,10 +0,0 @@
-<%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
-import type { VovkStrictConfig, VovkSegmentSchema } from 'vovk';
-
-export const fullSchema: {
-    $schema: string;
-    config: Partial<VovkStrictConfig>;
-    segments: {<% Object.values(t.fullSchema.segments).filter((segment) => segment.emitSchema).forEach((segment) => { %>
-      '<%= segment.segmentName %>': VovkSegmentSchema;<% }) %>
-    };
-};

package/client-templates/fullSchemaJson/full-schema.json.ejs

@@ -1 +0,0 @@
-<%- JSON.stringify(t.fullSchema, null, 2) %>

package/dist/dev/isSegmentSchemaEmpty.d.mts

@@ -1,2 +0,0 @@
-import type { VovkSegmentSchema } from 'vovk';
-export default function isSegmentSchemaEmpty(segmentSchema: VovkSegmentSchema): boolean;

package/dist/dev/isSegmentSchemaEmpty.mjs

@@ -1,4 +0,0 @@
-import isEmpty from 'lodash/isEmpty.js';
-export default function isSegmentSchemaEmpty(segmentSchema) {
-    return isEmpty(segmentSchema.controllers);
-}

package/dist/enums.d.mts

@@ -1,5 +0,0 @@
-export declare enum SchemaIdEnum {
-    CONFIG = "https://vovk.dev/api/schema/v3/config.json",
-    SEGMENT = "https://vovk.dev/api/schema/v3/segment.json",
-    FULL = "https://vovk.dev/api/schema/v3/full.json"
-}

package/dist/enums.mjs

@@ -1,6 +0,0 @@
-export var SchemaIdEnum;
-(function (SchemaIdEnum) {
-    SchemaIdEnum["CONFIG"] = "https://vovk.dev/api/schema/v3/config.json";
-    SchemaIdEnum["SEGMENT"] = "https://vovk.dev/api/schema/v3/segment.json";
-    SchemaIdEnum["FULL"] = "https://vovk.dev/api/schema/v3/full.json";
-})(SchemaIdEnum || (SchemaIdEnum = {}));