vovk-cli 0.0.1-draft.3 → 0.0.1-draft.300

package/dist/init/updateNPMScripts.mjs

@@ -1,12 +1,15 @@
-import NPMCliPackageJson from '@npmcli/package-json';
-export default async function updateNPMScripts(root, updateScriptsMode) {
-    const pkgJson = await NPMCliPackageJson.load(root);
+export function getDevScript(pkgJson, updateScriptsMode) {
+    const nextDev = pkgJson.content.scripts?.dev ?? 'next dev';
+    const nextDevFlags = nextDev.replace('next dev', '').trim();
+    return updateScriptsMode === 'explicit'
+        ? `PORT=3000 concurrently '${nextDev}' 'vovk dev' --kill-others`
+        : `vovk dev --next-dev${nextDevFlags ? ` -- ${nextDevFlags}` : ''}`;
+}
+export default async function updateNPMScripts(pkgJson, root, updateScriptsMode) {
     pkgJson.update({
         scripts: {
-            generate: 'vovk generate',
-            dev: updateScriptsMode === 'explicit'
-                ? "PORT=3000 concurrently 'vovk dev' 'next dev' --kill-others"
-                : 'vovk dev --next-dev',
+            ...pkgJson.content.scripts,
+            dev: getDevScript(pkgJson, updateScriptsMode),
         },
     });
     await pkgJson.save();

package/dist/init/updateTypeScriptConfig.d.mts

@@ -1 +1,4 @@
-export default function updateTypeScriptConfig(root: string): Promise<void>;
+export default function updateTypeScriptConfig(root: string, compilerOptions: {
+    experimentalDecorators?: true;
+    emitDecoratorMetadata?: true;
+}): Promise<void>;

package/dist/init/updateTypeScriptConfig.mjs

@@ -1,15 +1,19 @@
-import path from 'path';
-import fs from 'fs/promises';
+import path from 'node:path';
+import fs from 'node:fs/promises';
 import * as jsonc from 'jsonc-parser';
 import prettify from '../utils/prettify.mjs';
-export default async function updateTypeScriptConfig(root) {
+export default async function updateTypeScriptConfig(root, compilerOptions) {
     const tsconfigPath = path.join(root, 'tsconfig.json');
     const tsconfigContent = await fs.readFile(tsconfigPath, 'utf8');
-    // Use jsonc-parser to generate edits and modify the experimentalDecorators property
-    const edits = jsonc.modify(tsconfigContent, ['compilerOptions', 'experimentalDecorators'], true, {
-        formattingOptions: {},
-    });
-    // Apply the edits to the original content
-    const updatedContent = await prettify(jsonc.applyEdits(tsconfigContent, edits), tsconfigPath);
+    let updatedContent = tsconfigContent;
+    // Apply each compiler option
+    for (const [key, value] of Object.entries(compilerOptions)) {
+        const edits = jsonc.modify(updatedContent, ['compilerOptions', key], value, {
+            formattingOptions: {},
+        });
+        updatedContent = jsonc.applyEdits(updatedContent, edits);
+    }
+    // Prettify the final content
+    updatedContent = await prettify(updatedContent, tsconfigPath);
     await fs.writeFile(tsconfigPath, updatedContent, 'utf8');
 }

package/dist/initProgram.d.mts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function initProgram(program: Command): Command;

package/dist/initProgram.mjs

@@ -0,0 +1,22 @@
+import { Init } from './init/index.mjs';
+// reused at vovk-init
+export function initProgram(program) {
+    return program
+        .argument('[prefix]', 'directory to initialize project in', '.')
+        .description('Initialize Vovk.ts project')
+        .option('-y, --yes', 'skip all prompts and use default values')
+        .option('--log-level <level>', 'set log level', 'info')
+        .option('--use-npm', 'use npm as package manager')
+        .option('--use-yarn', 'use yarn as package manager')
+        .option('--use-pnpm', 'use pnpm as package manager')
+        .option('--use-bun', 'use bun as package manager')
+        .option('--skip-install', 'skip installing dependencies')
+        .option('--update-ts-config', 'update tsconfig.json')
+        .option('--update-scripts <mode>', 'update package.json scripts ("implicit" or "explicit")')
+        .option('--lang <languages...>', 'generate client for other programming languages by default ("py" for Python and "rs" for Rust are supported)')
+        .option('--validation-library <library>', 'validation library to use ("vovk-zod", "vovk-dto" or another); set to "none" to skip')
+        .option('--react-query', 'use @tanstack/react-query for data fetching inside components')
+        .option('--channel <channel>', 'channel to use for fetching packages', 'latest')
+        .option('--dry-run', 'do not write files to disk')
+        .action((prefix = '.', options) => new Init().main(prefix, options));
+}

package/dist/locateSegments.d.mts

@@ -1,5 +1,12 @@
+import type { VovkStrictConfig } from 'vovk';
+import type { ProjectInfo } from './getProjectInfo/index.mjs';
 export type Segment = {
     routeFilePath: string;
     segmentName: string;
 };
-export default function locateSegments(dir: string, rootDir?: string): Promise<Segment[]>;
+export declare function locateSegments({ dir, rootDir, config, log, }: {
+    dir: string | null;
+    rootDir?: string;
+    config: VovkStrictConfig | null;
+    log: ProjectInfo['log'];
+}): Promise<Segment[]>;

package/dist/locateSegments.mjs

@@ -1,10 +1,20 @@
-import { promises as fs } from 'fs';
-import * as path from 'path';
+import fs from 'node:fs/promises';
+import path from 'node:path';
 import getFileSystemEntryType from './utils/getFileSystemEntryType.mjs';
-export default async function locateSegments(dir, rootDir = dir) {
+export async function locateSegments({ dir, rootDir, config, log, }) {
     let results = [];
+    if (!dir)
+        return results; // If dir is null, return empty results because this isn't a Next.js app
+    rootDir = rootDir ?? dir;
+    let list = [];
     // Read the contents of the directory
-    const list = await fs.readdir(dir);
+    try {
+        list = (await fs.readdir(dir)).toSorted();
+    }
+    catch {
+        // do nothing
+        return results;
+    }
     // Iterate through each item in the directory
     for (const file of list) {
         const filePath = path.join(dir, file);
@@ -16,12 +26,12 @@ export default async function locateSegments(dir, rootDir = dir) {
                 const routeFilePath = path.join(filePath, 'route.ts');
                 if (await getFileSystemEntryType(routeFilePath)) {
                     // Calculate the basePath relative to the root directory
-                    const segmentName = path.relative(rootDir, dir);
+                    const segmentName = path.relative(rootDir, dir).replace(/\\/g, '/'); // windows fix
                     results.push({ routeFilePath, segmentName });
                 }
             }
             // Recursively search inside subdirectories
-            const subDirResults = await locateSegments(filePath, rootDir);
+            const subDirResults = await locateSegments({ dir: filePath, rootDir, config, log });
             results = results.concat(subDirResults);
         }
     }

package/dist/new/addClassToSegmentCode.d.mts

@@ -1,6 +1,5 @@
-export default function addClassToSegmentCode(segmentSourceCode: string, { sourceName, compiledName, type, importPath, }: {
+export default function addClassToSegmentCode(segmentSourceCode: string, { sourceName, compiledName, importPath, }: {
     sourceName: string;
     compiledName: string;
-    type: 'worker' | 'controller';
     importPath: string;
 }): string;

package/dist/new/addClassToSegmentCode.mjs

@@ -1,6 +1,10 @@
-import { Project, SyntaxKind } from 'ts-morph';
-export default function addClassToSegmentCode(segmentSourceCode, { sourceName, compiledName, type, importPath, }) {
-    const project = new Project();
+import { Project, QuoteKind, SyntaxKind } from 'ts-morph';
+export default function addClassToSegmentCode(segmentSourceCode, { sourceName, compiledName, importPath, }) {
+    const project = new Project({
+        manipulationSettings: {
+            quoteKind: QuoteKind.Single,
+        },
+    });
     const sourceFile = project.createSourceFile('route.ts', segmentSourceCode, { overwrite: true });
     // Add the import if it doesn't exist
     let importDeclaration = sourceFile.getImportDeclaration((imp) => {
@@ -12,8 +16,8 @@ export default function addClassToSegmentCode(segmentSourceCode, { sourceName, c
             moduleSpecifier: importPath,
         });
     }
-    // Get the variable declaration for controllers or workers
-    const variableDeclaration = sourceFile.getVariableDeclaration(`${type}s`);
+    // Get the variable declaration for controllers
+    const variableDeclaration = sourceFile.getVariableDeclaration('controllers');
     if (variableDeclaration) {
         const initializer = variableDeclaration.getInitializer();
         if (initializer && initializer.getKind() === SyntaxKind.ObjectLiteralExpression) {

package/dist/new/addCommonTerms.mjs

@@ -2,6 +2,7 @@ import pluralize from 'pluralize';
 // feel free to open a direct PR if you have more common terms to add
 const terms = [
     ['entity', 'entities'],
+    ['entry', 'entries'],
     ['regex', 'regexes'],
     ['index', 'indices'],
     ['matrix', 'matrices'],

package/dist/new/index.d.mts

@@ -1,2 +1,2 @@
-import type { NewOptions } from '../index.mjs';
-export default function newComponents(components: string[], options: NewOptions): Promise<void>;
+import type { NewOptions } from '../types.mjs';
+export declare function newComponents(components: string[], { dryRun, dir, templates, overwrite, noSegmentUpdate, empty, static: isStaticSegment }: NewOptions): Promise<void>;

package/dist/new/index.mjs

@@ -1,7 +1,8 @@
 import newModule from './newModule.mjs';
 import newSegment from './newSegment.mjs';
-export default async function newComponents(components, options) {
+export async function newComponents(components, { dryRun, dir, templates, overwrite, noSegmentUpdate, empty, static: isStaticSegment }) {
     if (components[0] === 'segment' || components[0] === 'segments') {
+        // vovk new segment [segmentName]
         let segmentNames = components
             .slice(1)
             .map((segmentName) => (segmentName === '""' || segmentName === "''" ? '' : segmentName));
@@ -9,10 +10,11 @@ export default async function newComponents(components, options) {
             segmentNames = [''];
         }
         for (const segmentName of segmentNames) {
-            await newSegment({ segmentName, dryRun: options.dryRun });
+            await newSegment({ segmentName, isStaticSegment, overwrite, dryRun });
         }
     }
     else {
+        // vovk new [what...] [moduleNameWithOptionalSegment]
         if (components.length < 2) {
             throw new Error('Invalid command invocation. Please provide at least two arguments.');
         }
@@ -21,6 +23,15 @@ export default async function newComponents(components, options) {
         if (!moduleNameWithOptionalSegment) {
             throw new Error('A module name with an optional segment cannot be empty');
         }
-        await newModule({ what, moduleNameWithOptionalSegment, dryRun: options.dryRun });
+        await newModule({
+            what,
+            moduleNameWithOptionalSegment,
+            dir,
+            templates,
+            overwrite,
+            noSegmentUpdate,
+            dryRun,
+            empty,
+        });
     }
 }

package/dist/new/newModule.d.mts

@@ -1,5 +1,10 @@
-export default function newModule({ what, moduleNameWithOptionalSegment, dryRun, }: {
+export default function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }: {
     what: string[];
     moduleNameWithOptionalSegment: string;
-    dryRun: boolean;
+    dryRun?: boolean;
+    dir?: string;
+    templates?: string[];
+    noSegmentUpdate?: boolean;
+    overwrite?: boolean;
+    empty?: boolean;
 }): Promise<void>;

package/dist/new/newModule.mjs

@@ -1,13 +1,15 @@
-import path from 'path';
-import fs from 'fs/promises';
-import getProjectInfo from '../getProjectInfo/index.mjs';
+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 chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
-import locateSegments from '../locateSegments.mjs';
-import addClassToSegmentCode from './addClassToSegmentCode.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,73 +20,97 @@ function splitByLast(str, delimiter = '/') {
     const after = str.substring(index + delimiter.length);
     return [before, after];
 }
-export default async function newModule({ what, moduleNameWithOptionalSegment, dryRun, }) {
-    const { config, log, apiDir, cwd } = await getProjectInfo();
-    const templates = config.templates;
+export default async function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }) {
+    const { config, log, cwd, apiDirAbsolutePath } = await getProjectInfo();
+    const segments = await locateSegments({ dir: apiDirAbsolutePath, 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;
         }
     });
-    // check if template exists
+    if (templatesFlag) {
+        if (templatesFlag.length > what.length) {
+            throw new Error('Too many templates provided');
+        }
+        templates = templatesFlag.reduce((acc, templatePath, index) => ({
+            ...acc,
+            [what[index]]: templatePath,
+        }), templates);
+    }
     for (const type of what) {
         if (!templates[type]) {
-            throw new Error(`Template for ${type} not found in config`);
+            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(`Segment ${segmentName} not found`);
+        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 { filePath, sourceName, compiledName, code } = await render(templateCode, {
+        const { dir: renderedDir, fileName, sourceName, compiledName, code, } = await render(templateCode, {
+            cwd,
             config,
             withService: what.includes('service'),
             segmentName,
             moduleName,
+            empty,
+            templateFileName: templateAbsolutePath,
+            isNodeNextResolution,
         });
-        const absoluteModulePath = path.join(cwd, config.modulesDir, filePath);
-        const dirName = path.dirname(absoluteModulePath);
+        const dir = dirFlag || renderedDir;
+        if (!dir) {
+            throw new Error(`The template for "${type}" does not provide a dir`);
+        }
+        if (!fileName) {
+            throw new Error(`The template for "${type}" does not provide a fileName`);
+        }
+        const absoluteModuleDir = path.join(cwd, dir);
+        const absoluteModulePath = path.join(absoluteModuleDir, fileName);
         const prettiedCode = await prettify(code, absoluteModulePath);
         if (!dryRun) {
-            if (await getFileSystemEntryType(absoluteModulePath)) {
+            if (!overwrite && (await getFileSystemEntryType(absoluteModulePath))) {
                 log.warn(`File ${chalkHighlightThing(absoluteModulePath)} already exists, skipping this "${type}"`);
             }
             else {
-                await fs.mkdir(dirName, { recursive: true });
+                await fs.mkdir(absoluteModuleDir, { recursive: true });
                 await fs.writeFile(absoluteModulePath, prettiedCode);
+                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`);
+            }
             const { routeFilePath } = segment;
             const segmentSourceCode = await fs.readFile(routeFilePath, 'utf-8');
-            const importPath = path.relative(dirName, absoluteModulePath).replace(/\.(ts|tsx)$/, '');
-            const newSegmentCode = addClassToSegmentCode(segmentSourceCode, {
-                sourceName,
-                compiledName,
-                type,
-                importPath,
-            });
-            if (!dryRun) {
-                await fs.writeFile(routeFilePath, newSegmentCode);
+            let importPath = path.relative(path.dirname(routeFilePath) + '/', absoluteModulePath).replace(/\.(ts|tsx)$/, '');
+            importPath += isNodeNextResolution ? '.ts' : '';
+            if (!noSegmentUpdate) {
+                const newSegmentCode = await prettify(addClassToSegmentCode(segmentSourceCode, {
+                    sourceName,
+                    compiledName,
+                    importPath,
+                }), routeFilePath);
+                if (!dryRun) {
+                    await fs.writeFile(routeFilePath, newSegmentCode);
+                }
             }
-            log.info(`Added ${chalkHighlightThing(sourceName)} ${type} to ${formatLoggedSegmentName(segmentName)} as ${chalkHighlightThing(compiledName)}`);
+            log.info(`Added ${chalkHighlightThing(sourceName)} ${type} as ${chalkHighlightThing(compiledName)} to ${formatLoggedSegmentName(segmentName)}`);
         }
-        log.info(`Created ${chalkHighlightThing(sourceName)} with ${chalkHighlightThing(type)} template for ${formatLoggedSegmentName(segmentName)}`);
     }
 }

package/dist/new/newSegment.d.mts

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

package/dist/new/newSegment.mjs

@@ -1,27 +1,34 @@
-import path from 'path';
-import fs from 'fs/promises';
+import path from 'node:path';
+import fs from 'node:fs/promises';
 import getProjectInfo from '../getProjectInfo/index.mjs';
 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, dryRun }) {
-    const { apiDir, cwd, log } = await getProjectInfo();
-    const absoluteSegmentRoutePath = path.join(cwd, apiDir, segmentName, '[[...vovk]]/route.ts');
-    if (await getFileSystemEntryType(absoluteSegmentRoutePath)) {
+import chalk from 'chalk';
+export default async function newSegment({ segmentName, isStaticSegment, overwrite, dryRun, }) {
+    const { apiDirAbsolutePath, log, config } = await getProjectInfo();
+    if (!apiDirAbsolutePath) {
+        throw new Error('No API directory found. Please ensure you are in a Nest.js project.');
+    }
+    const absoluteSegmentRoutePath = path.join(apiDirAbsolutePath, 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 { initSegment${isStaticSegment ? ', generateStaticAPI' : ''} } from 'vovk';
 
 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'} } = initSegment({
 ${segmentName ? `  segmentName: '${segmentName}',\n` : ''}  emitSchema: true,
-  workers,
   controllers,
 });
 `, absoluteSegmentRoutePath);
@@ -29,5 +36,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`)} to create a controller or modify the segment file manually`);
+    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,12 +1,12 @@
-import type { VovkConfig } from '../types.mjs';
-export default function render(codeTemplate: string, { config, withService, segmentName, moduleName, }: {
-    config: VovkConfig;
+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: VovkStrictConfig;
     withService: boolean;
     segmentName: string;
     moduleName: string;
-}): Promise<{
-    filePath: string;
-    sourceName: string;
-    compiledName: string;
-    code: string;
-}>;
+    empty?: boolean;
+    templateFileName: string;
+    isNodeNextResolution: boolean;
+}): Promise<VovkModuleRenderResult>;

package/dist/new/render.mjs

@@ -4,26 +4,51 @@ import _ from 'lodash';
 import pluralize from 'pluralize';
 import addCommonTerms from './addCommonTerms.mjs';
 addCommonTerms();
-export default async function render(codeTemplate, { config, withService, segmentName, moduleName, }) {
-    const getModulePath = (givenSegmentName, givenModuleName, fileName) => [givenSegmentName || config.rootSegmentModulesDirName, _.camelCase(givenModuleName), fileName]
+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
-        getModulePath,
+        nodeNextResolutionExt: {
+            ts: isNodeNextResolution ? '.ts' : '',
+            js: isNodeNextResolution ? '.js' : '',
+            cjs: isNodeNextResolution ? '.cjs' : '',
+            mjs: isNodeNextResolution ? '.mjs' : '',
+        },
+        defaultDir: getModuleDirName(segmentName, theThing),
         // libraries
         _, // lodash
         pluralize,
     };
-    // first, render the front matter because it can use ejs variables
-    const parsed = matter((await ejs.render(codeTemplate, templateVars, { async: true })).trim());
-    const { filePath, sourceName, compiledName } = parsed.data;
-    const templateContent = parsed.content;
-    const code = await ejs.render(templateContent, templateVars, { async: true });
-    return { filePath, sourceName, compiledName, code };
+    const parsed = matter((await ejs.render(codeTemplate, { t }, { async: true, filename: templateFileName })).trim());
+    const { dir, fileName, sourceName, compiledName } = parsed.data;
+    const code = empty ? (sourceName ? `export default class ${sourceName} {}` : '') : parsed.content;
+    return {
+        dir,
+        fileName,
+        sourceName,
+        compiledName,
+        code,
+    };
 }