vovk-cli 0.0.1-draft.20 → 0.0.1-draft.201

package/dist/new/newModule.mjs

@@ -1,13 +1,15 @@
 import path from 'node:path';
 import fs from 'node:fs/promises';
+import { getTsconfig } from 'get-tsconfig';
 import render from './render.mjs';
 import addClassToSegmentCode from './addClassToSegmentCode.mjs';
 import getProjectInfo from '../getProjectInfo/index.mjs';
-import locateSegments from '../locateSegments.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 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) {
@@ -18,19 +20,19 @@ function splitByLast(str, delimiter = '/') {
     const after = str.substring(index + delimiter.length);
     return [before, after];
 }
-export default async function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, }) {
-    const { config, log, apiDir, cwd } = await getProjectInfo();
-    let templates = config.templates;
+export default async function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }) {
+    const { config, log, cwd, apiDir } = await getProjectInfo();
+    const segments = await locateSegments({ dir: path.join(cwd, apiDir), config, log });
+    const isNodeNextResolution = ['node16', 'nodenext'].includes((await getTsconfig(cwd)?.config?.compilerOptions?.moduleResolution?.toLowerCase()) ?? '');
+    let templates = config.moduleTemplates;
     const [segmentName, moduleName] = splitByLast(moduleNameWithOptionalSegment);
-    // replace c by controller, s by service, w by worker, everything else keeps the same
+    // replace c by controller, s by service, everything else keeps the same
     what = what.map((s) => {
         switch (s) {
             case 'c':
                 return 'controller';
             case 's':
                 return 'service';
-            case 'w':
-                return 'worker';
             default:
                 return s;
         }
@@ -49,16 +51,13 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
             throw new Error(`Template for "${type}" not found`);
         }
     }
-    const segments = await locateSegments(apiDir);
     const segment = segments.find((s) => s.segmentName === segmentName);
     if (!segment) {
         throw new Error(`Unable to create module. Segment "${segmentName}" not found. Run "vovk new segment ${segmentName}" to create it`);
     }
     for (const type of what) {
         const templatePath = templates[type];
-        const templateAbsolutePath = templatePath.startsWith('/') || templatePath.startsWith('.')
-            ? path.resolve(cwd, templatePath)
-            : path.resolve(cwd, './node_modules', templatePath);
+        const templateAbsolutePath = resolveAbsoluteModulePath(templatePath, cwd);
         const templateCode = await fs.readFile(templateAbsolutePath, 'utf-8');
         const { dir: renderedDir, fileName, sourceName, compiledName, code, } = await render(templateCode, {
             cwd,
@@ -66,6 +65,9 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
             withService: what.includes('service'),
             segmentName,
             moduleName,
+            empty,
+            templateFileName: templateAbsolutePath,
+            isNodeNextResolution,
         });
         const dir = dirFlag || renderedDir;
         if (!dir) {
@@ -84,24 +86,24 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
             else {
                 await fs.mkdir(absoluteModuleDir, { recursive: true });
                 await fs.writeFile(absoluteModulePath, prettiedCode);
-                log.info(`Created ${chalkHighlightThing(fileName)} using ${chalkHighlightThing(`"${type}"`)} template for ${formatLoggedSegmentName(segmentName)}`);
+                log.info(`Created${empty ? ' empty' : ''} ${chalkHighlightThing(absoluteModulePath)} using ${chalkHighlightThing(`"${type}"`)} template for ${formatLoggedSegmentName(segmentName)}`);
             }
         }
-        if (type === 'controller' || type === 'worker') {
+        if (type === 'controller') {
             if (!sourceName) {
                 throw new Error(`The template for "${type}" does not provide a sourceName`);
             }
             if (!compiledName) {
-                throw new Error('The template for "${type}" does not provide a compiledName');
+                throw new Error(`The template for "${type}" does not provide a compiledName`);
             }
             const { routeFilePath } = segment;
             const segmentSourceCode = await fs.readFile(routeFilePath, 'utf-8');
-            const importPath = path.relative(path.dirname(routeFilePath), absoluteModulePath).replace(/\.(ts|tsx)$/, '');
+            let importPath = path.relative(path.dirname(routeFilePath) + '/', absoluteModulePath).replace(/\.(ts|tsx)$/, '');
+            importPath += isNodeNextResolution ? '.ts' : '';
             if (!noSegmentUpdate) {
                 const newSegmentCode = await prettify(addClassToSegmentCode(segmentSourceCode, {
                     sourceName,
                     compiledName,
-                    type,
                     importPath,
                 }), routeFilePath);
                 if (!dryRun) {

package/dist/new/newSegment.d.mts

@@ -1,5 +1,6 @@
-export default function newSegment({ segmentName, overwrite, dryRun, }: {
+export default function newSegment({ segmentName, isStaticSegment, overwrite, dryRun, }: {
     segmentName: string;
+    isStaticSegment?: boolean;
     overwrite?: boolean;
     dryRun?: boolean;
 }): Promise<void>;

package/dist/new/newSegment.mjs

@@ -5,23 +5,29 @@ import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import prettify from '../utils/prettify.mjs';
-export default async function newSegment({ segmentName, overwrite, dryRun, }) {
-    const { apiDir, cwd, log } = await getProjectInfo();
+import chalk from 'chalk';
+export default async function newSegment({ segmentName, isStaticSegment, overwrite, dryRun, }) {
+    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.`);
     }
-    const code = await prettify(`import { initVovk } from 'vovk';
+    const code = await prettify(`import { initVovk${isStaticSegment ? ', generateStaticAPI' : ''} } from 'vovk';
+
+export const runtime = 'edge';
 
 const controllers = {};
-const workers = {};
 
 export type Controllers = typeof controllers;
-export type Workers = typeof workers;
-
-export const { GET, POST, PATCH, PUT, HEAD, OPTIONS, DELETE } = initVovk({
+${isStaticSegment
+        ? `
+export function generateStaticParams() {
+  return generateStaticAPI(controllers);
+}
+`
+        : ''}
+export const { GET${isStaticSegment ? '' : ', POST, PATCH, PUT, HEAD, OPTIONS, DELETE'} } = initVovk({
 ${segmentName ? `  segmentName: '${segmentName}',\n` : ''}  emitSchema: true,
-  workers,
   controllers,
 });
 `, absoluteSegmentRoutePath);
@@ -29,5 +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}. Run ${chalkHighlightThing(`vovk new controller ${[segmentName, 'someName'].filter(Boolean).join('/')}`)} to create a new controller`);
+    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 ${path.join(config.modulesDir, dir)} folder for this segment`);
 }

package/dist/new/render.d.mts

@@ -1,8 +1,12 @@
-import type { VovkConfig, VovkModuleRenderResult } from '../types.mjs';
-export default function render(codeTemplate: string, { config, withService, segmentName, moduleName, }: {
+import type { VovkStrictConfig } from 'vovk';
+import type { VovkModuleRenderResult } from '../types.mjs';
+export default function render(codeTemplate: string, { config, withService, segmentName, moduleName, empty, templateFileName, isNodeNextResolution, }: {
     cwd: string;
-    config: VovkConfig;
+    config: VovkStrictConfig;
     withService: boolean;
     segmentName: string;
     moduleName: string;
+    empty?: boolean;
+    templateFileName: string;
+    isNodeNextResolution: boolean;
 }): Promise<VovkModuleRenderResult>;

package/dist/new/render.mjs

@@ -4,25 +4,46 @@ import _ from 'lodash';
 import pluralize from 'pluralize';
 import addCommonTerms from './addCommonTerms.mjs';
 addCommonTerms();
-export default async function render(codeTemplate, { config, withService, segmentName, moduleName, }) {
+export default async function render(codeTemplate, { config, withService, segmentName, moduleName, empty, templateFileName, isNodeNextResolution, }) {
     const getModuleDirName = (givenSegmentName, givenModuleName) => [config.modulesDir, givenSegmentName || config.rootSegmentModulesDirName, _.camelCase(givenModuleName)]
         .filter(Boolean)
         .join('/');
-    const templateVars = {
-        // input
+    const theThing = _.camelCase(moduleName);
+    const TheThing = _.upperFirst(theThing);
+    const the_thing = _.snakeCase(moduleName);
+    const THE_THING = _.toUpper(the_thing);
+    const the__thing = _.kebabCase(moduleName);
+    const t = {
+        // module name variations
+        moduleName,
+        theThing,
+        theThings: pluralize(theThing),
+        TheThing,
+        TheThings: pluralize(TheThing),
+        the_thing,
+        the_things: pluralize(the_thing),
+        THE_THING,
+        THE_THINGS: pluralize(THE_THING),
+        'the-thing': the__thing,
+        'the-things': pluralize(the__thing),
+        // data
         config,
         withService,
         segmentName,
-        moduleName,
-        // utils
-        getModuleDirName,
+        nodeNextResolutionExt: {
+            ts: isNodeNextResolution ? '.ts' : '',
+            js: isNodeNextResolution ? '.js' : '',
+            cjs: isNodeNextResolution ? '.cjs' : '',
+            mjs: isNodeNextResolution ? '.mjs' : '',
+        },
+        defaultDir: getModuleDirName(segmentName, theThing),
         // libraries
         _, // lodash
         pluralize,
     };
-    const parsed = matter((await ejs.render(codeTemplate, templateVars, { async: true })).trim());
+    const parsed = matter((await ejs.render(codeTemplate, { t }, { async: true, filename: templateFileName })).trim());
     const { dir, fileName, sourceName, compiledName } = parsed.data;
-    const code = parsed.content;
+    const code = empty ? (sourceName ? `export default class ${sourceName} {}` : '') : parsed.content;
     return {
         dir,
         fileName,

package/dist/types.d.mts

@@ -1,42 +1,5 @@
 import type { LogLevelNames } from 'loglevel';
-export type KnownAny = any;
-export type VovkDevEnv = {
-    PORT?: string;
-    VOVK_CLIENT_OUT_DIR?: string;
-    VOVK_SCHEMA_OUT_DIR?: string;
-    VOVK_FETCHER?: string;
-    VOVK_VALIDATE_ON_CLIENT?: string;
-    VOVK_MODULES_DIR?: string;
-    VOVK_VALIDATION_LIBRARY?: 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;
-    __VOVK_START_WATCHER_IN_STANDALONE_MODE__?: 'true';
-};
-export type VovkConfig = {
-    clientOutDir?: string;
-    schemaOutDir?: string;
-    fetcher?: string;
-    validateOnClient?: string | null;
-    modulesDir?: string;
-    validationLibrary?: string | null;
-    rootEntry?: string;
-    origin?: string;
-    rootSegmentModulesDirName?: string;
-    logLevel?: LogLevelNames;
-    prettifyClient?: boolean;
-    devHttps?: boolean;
-    templates?: {
-        service?: string;
-        controller?: string;
-        worker?: string;
-        [key: string]: string | undefined;
-    };
-};
+import type { VovkStrictConfig } from 'vovk';
 export type VovkModuleRenderResult = {
     fileName: string;
     dir: string;
@@ -45,11 +8,31 @@ export type VovkModuleRenderResult = {
     code: string;
 };
 export interface DevOptions {
-    clientOut?: string;
+    schemaOut?: string;
     nextDev?: boolean;
+    exit?: boolean;
 }
 export interface GenerateOptions {
-    clientOut?: string;
+    prettify?: boolean;
+    configPath?: string;
+    schemaPath?: string;
+    openapiSpec?: string;
+    watch?: boolean | string;
+    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;
+    schema?: string;
+    openapiSpec?: string;
 }
 export interface InitOptions {
     yes?: boolean;
@@ -62,8 +45,9 @@ export interface InitOptions {
     updateTsConfig?: boolean;
     updateScripts?: 'implicit' | 'explicit';
     validationLibrary?: string | null;
-    validateOnClient?: boolean;
+    reactQuery?: boolean;
     dryRun?: boolean;
+    lang?: string[];
     channel?: 'latest' | 'beta' | 'draft';
 }
 export interface NewOptions {
@@ -72,4 +56,19 @@ export interface NewOptions {
     dir?: string;
     overwrite?: boolean;
     noSegmentUpdate?: boolean;
+    empty?: boolean;
+    static?: boolean;
 }
+export type VovkEnv = {
+    PORT?: string;
+    VOVK_SCHEMA_OUT_DIR?: string;
+    VOVK_ORIGIN?: string;
+    VOVK_ROOT_ENTRY?: string;
+    VOVK_API_ENTRY_POINT?: string;
+    VOVK_LOG_LEVEL?: LogLevelNames;
+    VOVK_PRETTIFY_CLIENT?: string;
+    VOVK_DEV_HTTPS?: string;
+    __VOVK_START_WATCHER_IN_STANDALONE_MODE__?: 'true';
+    __VOVK_SCHEMA_OUT_FLAG__?: string;
+    __VOVK_EXIT__?: 'true' | 'false';
+};

package/dist/utils/debounceWithArgs.d.mts

@@ -1,2 +1,2 @@
-import { KnownAny } from '../types.mjs';
-export default function debounceWithArgs<T extends (...args: KnownAny[]) => KnownAny>(fn: T, wait: number): (...args: Parameters<T>) => void | Promise<void>;
+import type { KnownAny } from 'vovk';
+export default function debounceWithArgs<Callback extends (...args: KnownAny[]) => KnownAny>(callback: Callback, wait: number): (...args: Parameters<Callback>) => Promise<Awaited<ReturnType<Callback>>>;

package/dist/utils/debounceWithArgs.mjs

@@ -1,14 +1,29 @@
-import debounce from 'lodash/debounce.js';
-export default function debounceWithArgs(fn, wait) {
-    const debouncedFunctions = new Map();
+export default function debounceWithArgs(callback, wait) {
+    // Stores timeouts keyed by the stringified arguments
+    const timeouts = new Map();
     return (...args) => {
+        // Convert arguments to a JSON string (or any other stable key generation)
         const key = JSON.stringify(args);
-        if (!debouncedFunctions.has(key)) {
-            debouncedFunctions.set(key, debounce(fn, wait));
-        }
-        const debouncedFn = debouncedFunctions.get(key);
-        if (debouncedFn) {
-            debouncedFn(...args);
+        // Clear any existing timer for this specific key
+        if (timeouts.has(key)) {
+            clearTimeout(timeouts.get(key));
         }
+        // Return a promise that resolves/rejects after the debounce delay
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(async () => {
+                try {
+                    const result = await callback(...args);
+                    resolve(result);
+                }
+                catch (error) {
+                    reject(error);
+                }
+                finally {
+                    // Remove the entry once the callback is invoked
+                    timeouts.delete(key);
+                }
+            }, wait);
+            timeouts.set(key, timeoutId);
+        });
     };
 }

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/getAvailablePort.mjs

@@ -1,5 +1,5 @@
 import net from 'node:net';
-// TODO check comments
+// Created with AI
 /**
  * Checks if a port is available.
  * @param {number} port - The port to check.

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

@@ -0,0 +1,3 @@
+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

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

package/dist/utils/removeUnlistedDirectories.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Removes all directories in a folder that aren't in the provided allowlist
+ * Supports nested directory paths like 'foo/bar/baz'
+ *
+ * @param folderPath - The path to the folder to process
+ * @param allowedDirs - Array of relative directory paths to keep
+ * @returns Promise that resolves when all operations are complete
+ */
+declare function removeUnlistedDirectories(folderPath: string, allowedDirs: string[]): Promise<void>;
+export default removeUnlistedDirectories;

package/dist/utils/removeUnlistedDirectories.mjs

@@ -0,0 +1,61 @@
+import fs from 'fs/promises';
+import path from 'path';
+import getFileSystemEntryType, { FileSystemEntryType } from './getFileSystemEntryType.mjs';
+/**
+ * Removes all directories in a folder that aren't in the provided allowlist
+ * Supports nested directory paths like 'foo/bar/baz'
+ *
+ * @param folderPath - The path to the folder to process
+ * @param allowedDirs - Array of relative directory paths to keep
+ * @returns Promise that resolves when all operations are complete
+ */
+async function removeUnlistedDirectories(folderPath, allowedDirs) {
+    // Normalize all allowed paths to use the system-specific separator
+    const normalizedAllowedDirs = allowedDirs.map((dir) => dir.split('/').join(path.sep));
+    // Process the directory tree recursively
+    await processDirectory(folderPath, '', normalizedAllowedDirs);
+}
+/**
+ * Recursively processes directories to determine which should be kept or removed
+ *
+ * @param basePath - The absolute base path being processed
+ * @param relativePath - The current relative path from the base
+ * @param allowedDirs - Normalized list of allowed directory paths
+ */
+async function processDirectory(basePath, relativePath, allowedDirs) {
+    const currentDirPath = path.join(basePath, relativePath);
+    // check if the current path is a directory
+    const type = await getFileSystemEntryType(currentDirPath);
+    if (type !== FileSystemEntryType.DIRECTORY) {
+        // If it's not a directory, return early
+        return;
+    }
+    // Read all entries in the current directory
+    const entries = await fs.readdir(currentDirPath, { withFileTypes: true });
+    // Process only directories
+    const dirEntries = entries.filter((entry) => entry.isDirectory());
+    // Check each directory
+    for (const dir of dirEntries) {
+        // Calculate the new relative path
+        const newRelativePath = relativePath ? path.join(relativePath, dir.name) : dir.name;
+        // Check if this directory or any of its subdirectories should be kept
+        const shouldKeep = allowedDirs.some((allowedDir) => {
+            // Direct match
+            if (allowedDir === newRelativePath)
+                return true;
+            // Check if it's a parent path of an allowed directory
+            // e.g. "foo" is a parent of "foo/bar/baz"
+            return allowedDir.startsWith(newRelativePath + path.sep);
+        });
+        if (shouldKeep) {
+            // Recursively process this directory's contents
+            await processDirectory(basePath, newRelativePath, allowedDirs);
+        }
+        else {
+            // Remove this directory since it's not in the allowed list
+            const fullPath = path.join(basePath, newRelativePath);
+            await fs.rm(fullPath, { recursive: true, force: true });
+        }
+    }
+}
+export default removeUnlistedDirectories;

package/dist/utils/resolveAbsoluteModulePath.d.mts

@@ -0,0 +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

@@ -0,0 +1,32 @@
+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('.')) {
+        return path.resolve(cwd, modulePath);
+    }
+    // For npm package names, use Node's module resolution algorithm
+    try {
+        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 (e) {
+        // eslint-disable-next-line no-console
+        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/module-templates/Controller.ts.ejs

@@ -0,0 +1,50 @@
+<% const vars = { 
+  rpcModuleName: t.TheThing + 'Controller',
+  ServiceName: t.TheThing + 'Service',
+}; %>
+---
+dir: <%= t.defaultDir %>
+fileName: <%= vars.rpcModuleName + '.ts' %>
+sourceName: <%= vars.rpcModuleName %>
+compiledName: <%= t.TheThing + 'RPC' %>
+---
+
+import { prefix, get, put, post, del, type VovkRequest } from 'vovk';
+<% if(t.withService) { %>
+import <%= vars.ServiceName %> from './<%= vars.ServiceName %><%= t.resolutionExt %>';
+<% } %>
+
+@prefix('<%= t['the-things'] %>')
+export default class <%= vars.rpcModuleName %> {
+    @get()
+    static get<%= t.TheThings %> = async (req: VovkRequest<null, { search: string }>) => {
+        const search = req.nextUrl.searchParams.get('search');
+        <% if(t.withService) { %>
+        return <%= vars.ServiceName %>.get<%= t.TheThings %>(search);
+        <% } else { %>
+        return { results: [], search };
+        <% } %>
+    }
+
+    @put(':id')
+    static update<%= t.TheThing %> = 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');
+        <% if(t.withService) { %>
+        return <%= vars.ServiceName %>.update<%= t.TheThing %>(id, q, body);
+        <% } else { %>
+        return { id, body, q };
+        <% } %>
+    };
+
+    @post()
+    static create<%= t.TheThing %> = () => {
+        // ...
+    };
+
+    @del(':id')
+    static delete<%= t.TheThing %> = () => {
+        // ...
+    };
+}

package/module-templates/Service.ts.ejs

@@ -0,0 +1,28 @@
+<% const vars = {
+  rpcModuleName: t.TheThing + 'Controller',
+  ServiceName: t.TheThing + 'Service',
+}; %>
+---
+dir: <%= t.defaultDir %>
+fileName: <%= vars.ServiceName + '.ts' %>
+sourceName: <%= vars.ServiceName %>
+---
+
+import type { VovkBody, VovkQuery } from 'vovk';
+import type <%= vars.rpcModuleName %> from './<%= vars.rpcModuleName %><%= t.nodeNextResolutionTsExt %>';
+
+export default class <%= vars.ServiceName %> {
+  static get<%= t.TheThings %> = (search: VovkQuery<typeof <%= vars.rpcModuleName %>.get<%= t.TheThings %>>['search']) => {
+    return { results: [], search };
+  };
+
+  static update<%= t.TheThing %> = (
+    id: string,
+    q: VovkQuery<typeof <%= vars.rpcModuleName %>.update<%= t.TheThing %>>['q'],
+    body: VovkBody<typeof <%= vars.rpcModuleName %>.update<%= t.TheThing %>>
+  ) => {
+    return { id, q, body };
+  };
+
+  // ...
+}