vovk-cli 0.0.1-draft.88 → 0.0.1-draft.90

package/client-templates/main/main.cjs.ejs

@@ -1,11 +1,11 @@
 <%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
-const { default: fetcher } = require('<%= template.imports.fetcher %>');
-const { default: createRPC } = require('<%= template.imports.createRPC %>');
-const schema = require('<%= template.imports.schema %>');
-const { default: validateOnClient = null } = <%- template.imports.validateOnClient ? `require('${template.imports.validateOnClient}')` : '{}'%>;
-const apiRoot = '<%= template.apiRoot %>';
-<% template.segments.forEach((segment) => { 
-  Object.keys(template.fullSchema[segment.segmentName].controllers).forEach((key) => { %>
+const { default: fetcher } = require('<%= t.imports.fetcher %>');
+const { default: createRPC } = require('<%= t.imports.createRPC %>');
+const schema = require('<%= t.imports.schema %>');
+const { default: validateOnClient = null } = <%- t.imports.validateOnClient ? `require('${t.imports.validateOnClient}')` : '{}'%>;
+const apiRoot = '<%= t.apiRoot %>';
+<% t.segments.forEach((segment) => { 
+  Object.keys(t.fullSchema[segment.segmentName].controllers).forEach((key) => { %>
 exports.<%= key %> = createRPC(
   schema['<%= segment.segmentName %>'].controllers.<%= key %>, 
   '<%= segment.segmentName %>', 

package/client-templates/main/main.d.cts.ejs

@@ -1,14 +1,14 @@
 
 <%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
 import type { VovkClientFetcher } from 'vovk';
-import type fetcher from '<%= template.imports.fetcher %>';
-import type createRPC from '<%= template.imports.createRPC %>';
-<% template.segments.forEach((segment, i) => { if(Object.keys(template.fullSchema[segment.segmentName].controllers).length) { %>
+import type fetcher from '<%= t.imports.fetcher %>';
+import type createRPC from '<%= t.imports.createRPC %>';
+<% t.segments.forEach((segment, i) => { if(Object.keys(t.fullSchema[segment.segmentName].controllers).length) { %>
 import type { Controllers as Controllers<%= i %> } from "<%= segment.segmentImportPath %>";
 <% }}) %>
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
-<% template.segments.forEach((segment, i) => {
-  Object.keys(template.fullSchema[segment.segmentName].controllers).forEach((key) => { %>
+<% t.segments.forEach((segment, i) => {
+  Object.keys(t.fullSchema[segment.segmentName].controllers).forEach((key) => { %>
 export const <%= key %>: ReturnType<typeof createRPC<Controllers<%= i %>["<%= key %>"], Options>>;
   <% }) 
 }) %>

package/client-templates/module/module.d.mts.ejs

@@ -1,14 +1,14 @@
 
 <%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
 import type { VovkClientFetcher } from 'vovk';
-import type fetcher from '<%= template.imports.module.fetcher %>';
-import type createRPC from '<%= template.imports.module.createRPC %>';
-<% template.segments.forEach((segment, i) => { if(Object.keys(template.fullSchema[segment.segmentName].controllers).length) { %>
+import type fetcher from '<%= t.imports.module.fetcher %>';
+import type createRPC from '<%= t.imports.module.createRPC %>';
+<% t.segments.forEach((segment, i) => { if(Object.keys(t.fullSchema[segment.segmentName].controllers).length) { %>
 import type { Controllers as Controllers<%= i %> } from "<%= segment.segmentImportPath %>";
 <% }}) %>
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
-<% template.segments.forEach((segment, i) => { 
-  Object.keys(template.fullSchema[segment.segmentName].controllers).forEach((key) => { %>
+<% t.segments.forEach((segment, i) => { 
+  Object.keys(t.fullSchema[segment.segmentName].controllers).forEach((key) => { %>
 export const <%= key %>: ReturnType<typeof createRPC<Controllers<%= i %>["<%= key %>"], Options>>;
   <% }) 
 }) %>

package/client-templates/module/module.mjs.ejs

@@ -1,18 +1,18 @@
 <%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
-import fetcherImport from '<%= template.imports.module.fetcher %>';
-import createRPCImport from '<%= template.imports.module.createRPC %>';
-import schema from '<%= template.imports.module.schema %>';
-<% if (template.imports.module.validateOnClient) { %>
-import validateOnClientImport from '<%= template.imports.module.validateOnClient %>';
+import fetcherImport from '<%= t.imports.module.fetcher %>';
+import createRPCImport from '<%= t.imports.module.createRPC %>';
+import schema from '<%= t.imports.module.schema %>';
+<% if (t.imports.module.validateOnClient) { %>
+import validateOnClientImport from '<%= t.imports.module.validateOnClient %>';
 const validateOnClient = validateOnClientImport.default || validateOnClientImport;
 <% } else { %>
 const validateOnClient = undefined;
 <% } %>
-const apiRoot = '<%= template.apiRoot %>';
+const apiRoot = '<%= t.apiRoot %>';
 const fetcher = fetcherImport.default || fetcherImport;
 const createRPC = createRPCImport.default || createRPCImport;
-<% template.segments.forEach((segment, i) => {
-  Object.keys(template.fullSchema[segment.segmentName].controllers).forEach((key) => { %>
+<% t.segments.forEach((segment, i) => {
+  Object.keys(t.fullSchema[segment.segmentName].controllers).forEach((key) => { %>
 export const <%= key %> = createRPC(
   schema['<%= segment.segmentName %>'].controllers.<%= key %>, 
   '<%= segment.segmentName %>', 

package/client-templates/ts/index.ts.ejs

@@ -1,21 +1,21 @@
 <%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
 import type { VovkClientFetcher } from 'vovk';
-import fetcher from '<%= template.imports.fetcher %>';
-import createRPC from '<%= template.imports.createRPC %>';
-import schema from '<%= template.imports.schema %>';
-<% template.segments.forEach((segment, i) => { if(Object.keys(template.fullSchema[segment.segmentName].controllers).length) { %>
+import fetcher from '<%= t.imports.fetcher %>';
+import createRPC from '<%= t.imports.createRPC %>';
+import schema from '<%= t.imports.schema %>';
+<% t.segments.forEach((segment, i) => { if(Object.keys(t.fullSchema[segment.segmentName].controllers).length) { %>
 import type { Controllers as Controllers<%= i %> } from "<%= segment.segmentImportPath %>";
 <% }}) %>
-<% if (template.imports.validateOnClient) { %>
-import validateOnClient from '<%= template.imports.validateOnClient %>';
+<% if (t.imports.validateOnClient) { %>
+import validateOnClient from '<%= t.imports.validateOnClient %>';
 <% } else { %>
 const validateOnClient = undefined;
 <% } %>
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
-const apiRoot = '<%= template.apiRoot %>';
+const apiRoot = '<%= t.apiRoot %>';
 
-<% template.segments.forEach((segment, i) => { %>
-  <% Object.keys(template.fullSchema[segment.segmentName].controllers).forEach((key) => { %>
+<% t.segments.forEach((segment, i) => { %>
+  <% Object.keys(t.fullSchema[segment.segmentName].controllers).forEach((key) => { %>
 export const <%= key %> = createRPC<Controllers<%= i %>["<%= key %>"], Options>(
   schema['<%= segment.segmentName %>'].controllers.<%= key %>, 
   '<%= segment.segmentName %>', 

package/dist/dev/index.mjs

@@ -5,7 +5,6 @@ import { Agent, setGlobalDispatcher } from 'undici';
 import keyBy from 'lodash/keyBy.js';
 import capitalize from 'lodash/capitalize.js';
 import debounce from 'lodash/debounce.js';
-import isEmpty from 'lodash/isEmpty.js';
 import once from 'lodash/once.js';
 import { debouncedEnsureSchemaFiles } from './ensureSchemaFiles.mjs';
 import writeOneSchemaFile from './writeOneSchemaFile.mjs';
@@ -16,6 +15,7 @@ import generate from '../generate/index.mjs';
 import locateSegments from '../locateSegments.mjs';
 import debounceWithArgs from '../utils/debounceWithArgs.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
+import isSchemaEmpty from './isSchemaEmpty.mjs';
 export class VovkDev {
     #projectInfo;
     #segments = [];
@@ -280,7 +280,7 @@ export class VovkDev {
                 log.info(`Schema for ${formatLoggedSegmentName(segment.segmentName)} has been updated in ${timeTook}ms`);
             }
         }
-        else if (schema && !isEmpty(schema.controllers)) {
+        else if (schema && !isSchemaEmpty(schema)) {
             log.error(`Non-empty schema provided for ${formatLoggedSegmentName(segment.segmentName)} but "emitSchema" is false`);
         }
         if (this.#segments.every((s) => this.#schemas[s.segmentName])) {

package/dist/generate/index.mjs

@@ -23,7 +23,7 @@ export default async function generate({ projectInfo, segments, segmentsSchema,
     }
     const now = Date.now();
     // Data for the EJS templates:
-    const template = {
+    const t = {
         apiRoot,
         imports: clientImports,
         segments,
@@ -37,7 +37,7 @@ export default async function generate({ projectInfo, segments, segmentsSchema,
             const templateContent = await fs.readFile(templatePath, 'utf-8');
             // Render the template
             let rendered = templatePath.endsWith('.ejs')
-                ? ejs.render(templateContent, { template }, {
+                ? ejs.render(templateContent, { t }, {
                     filename: templatePath,
                 })
                 : templateContent;
@@ -79,6 +79,6 @@ export default async function generate({ projectInfo, segments, segmentsSchema,
         }
         return null;
     }));
-    log.info(`Client generated from template${usedTemplateNames.length !== 1 ? 's' : ''} ${chalkHighlightThing(usedTemplateNames.map((s) => `"${s}"`).join(', '))}${unusedTemplateNames.length ? ` (files generated from template${unusedTemplateNames.length !== 1 ? 's' : ''} ${chalkHighlightThing(unusedTemplateNames.map((s) => `"${s}"`).join(', '))} are up to date)` : ''} at ${clientOutDirAbsolutePath} in ${Date.now() - now}ms`);
+    log.info(`Client generated from template${usedTemplateNames.length !== 1 ? 's' : ''} ${chalkHighlightThing(usedTemplateNames.map((s) => `"${s}"`).join(', '))}${unusedTemplateNames.length ? ` (${chalkHighlightThing(unusedTemplateNames.map((s) => `"${s}"`).join(', '))} ${unusedTemplateNames.length !== 1 ? 'are' : 'is'} up to date)` : ''} at ${clientOutDirAbsolutePath} in ${Date.now() - now}ms`);
     return { written: true, path: clientOutDirAbsolutePath };
 }

package/dist/index.mjs

@@ -102,6 +102,7 @@ program
     .option('-o, --overwrite', 'overwrite existing files')
     .option('--template, --templates <templates...>', 'override config template; accepts an array of strings that correspond the order of the components')
     .option('--dir <dirname>', 'override dirName in template file; relative to the root of the project')
+    .option('--empty', 'create an empty module')
     .option('--no-segment-update', 'do not update segment files when creating a new module')
     .option('--dry-run', 'do not write files to disk')
     .action((components, options) => newComponents(components, options));

package/dist/new/index.d.mts

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

package/dist/new/index.mjs

@@ -1,6 +1,6 @@
 import newModule from './newModule.mjs';
 import newSegment from './newSegment.mjs';
-export default async function newComponents(components, { dryRun, dir, templates, overwrite, noSegmentUpdate }) {
+export default async function newComponents(components, { dryRun, dir, templates, overwrite, noSegmentUpdate, empty }) {
     if (components[0] === 'segment' || components[0] === 'segments') {
         // vovk new segment [segmentName]
         let segmentNames = components
@@ -31,6 +31,7 @@ export default async function newComponents(components, { dryRun, dir, templates
             overwrite,
             noSegmentUpdate,
             dryRun,
+            empty,
         });
     }
 }

package/dist/new/newModule.d.mts

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

package/dist/new/newModule.mjs

@@ -18,7 +18,7 @@ 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, }) {
+export default async function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }) {
     const { config, log, apiDir, cwd } = await getProjectInfo();
     let templates = config.templates;
     const [segmentName, moduleName] = splitByLast(moduleNameWithOptionalSegment);
@@ -64,6 +64,7 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
             withService: what.includes('service'),
             segmentName,
             moduleName,
+            empty,
         });
         const dir = dirFlag || renderedDir;
         if (!dir) {

package/dist/new/render.d.mts

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

package/dist/new/render.mjs

@@ -4,25 +4,48 @@ 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, }) {
     const getModuleDirName = (givenSegmentName, givenModuleName) => [config.modulesDir, givenSegmentName || config.rootSegmentModulesDirName, _.camelCase(givenModuleName)]
         .filter(Boolean)
         .join('/');
-    const templateVars = {
-        // input
+    /*
+      <% var modulePascalName = _.upperFirst(_.camelCase(moduleName)); %>
+  <% var modulePascalNamePlural = pluralize(modulePascalName); %>
+  <% var controllerName = modulePascalName + 'Controller'; %>
+  <% var compiledName = modulePascalName + 'RPC'; %>
+  <% var serviceName = modulePascalName + 'Service'; %>
+  <% var prefix = pluralize(_.kebabCase(moduleName).toLowerCase()); %>
+      */
+    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,
+        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 })).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

@@ -82,4 +82,5 @@ export interface NewOptions {
     dir?: string;
     overwrite?: boolean;
     noSegmentUpdate?: boolean;
+    empty?: boolean;
 }

package/package.json

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

package/templates/controller.ejs

@@ -1,52 +1,50 @@
-<% var modulePascalName = _.upperFirst(_.camelCase(moduleName)); %>
-<% var modulePascalNamePlural = pluralize(modulePascalName); %>
-<% var controllerName = modulePascalName + 'Controller'; %>
-<% var compiledName = modulePascalName + 'RPC'; %>
-<% var serviceName = modulePascalName + 'Service'; %>
-<% var prefix = pluralize(_.kebabCase(moduleName).toLowerCase()); %>
+<% const vars = { 
+  ControllerName: t.TheThing + 'Controller',
+  ServiceName = t.TheThing + 'Service',
+}; %>
 ---
-dir: <%= getModuleDirName(segmentName, moduleName) %>
-fileName: <%= controllerName + '.ts' %>
-sourceName: <%= controllerName %>
-compiledName: <%= compiledName %>
+dir: <%= t.defaultDir %>
+fileName: <%= vars.ControllerName + '.ts' %>
+sourceName: <%= vars.ControllerName %>
+compiledName: <%= t.TheThing + 'RPC' %>
 ---
 
 import { prefix, get, put, post, del, type VovkRequest } from 'vovk';
-<% if(withService) { %>
-import <%= serviceName %> from './<%= serviceName %>';
+<% if(t.withService) { %>
+import <%= vars.ServiceName %> from './<%= vars.ServiceName %>';
 <% } %>
 
-@prefix('<%= prefix %>')
-export default class <%= controllerName %> {
+@prefix('<%= t['the-things'] %>')
+export default class <%= vars.ControllerName %> {
     @get()
-    static get<%= modulePascalNamePlural %> = async (req: VovkRequest<null, { search: string }>) => {
+    static get<%= t.TheThings %> = async (req: VovkRequest<null, { search: string }>) => {
         const search = req.nextUrl.searchParams.get('search');
-        <% if(withService) { %>
-        return <%= serviceName %>.get<%= modulePascalNamePlural %>(search);
+        <% if(t.withService) { %>
+        return <%= vars.ServiceName %>.get<%= t.TheThings %>(search);
         <% } else { %>
         return { results: [], search };
         <% } %>
     }
 
     @put(':id')
-    static update<%= modulePascalName %> = async (req: VovkRequest<{ foo: 'bar' | 'baz' }, { q: string }>, params: { id: string }) => {
+    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(withService) { %>
-        return <%= serviceName %>.update<%= modulePascalName %>(id, q, body);
+        <% if(t.withService) { %>
+        return <%= vars.ServiceName %>.update<%= t.TheThing %>(id, q, body);
         <% } else { %>
         return { id, body, q };
         <% } %>
     };
 
     @post()
-    static create<%= modulePascalName %> = () => {
+    static create<%= t.TheThing %> = () => {
         // ...
     };
 
     @del(':id')
-    static delete<%= modulePascalName %> = () => {
+    static delete<%= t.TheThing %> = () => {
         // ...
     };
 }

package/templates/service.ejs

@@ -1,24 +1,24 @@
-<% var modulePascalName = _.upperFirst(_.camelCase(moduleName)); %>
-<% var modulePascalNamePlural = pluralize(modulePascalName); %>
-<% var serviceName = modulePascalName + 'Service'; %>
-<% var controllerName = modulePascalName + 'Controller'; %>
+<% const vars = {
+  ControllerName: t.TheThing + 'Controller',
+  ServiceName: t.TheThing + 'Service',
+}; %>
 ---
-dir: <%= getModuleDirName(segmentName, moduleName) %>
-fileName: <%= serviceName + '.ts' %>
+dir: <%= t.defaultDir %>
+fileName: <%= vars.ServiceName + '.ts' %>
 ---
 
 import type { VovkControllerBody, VovkControllerQuery } from 'vovk';
-import type <%= controllerName %> from './<%= controllerName %>';
+import type <%= vars.ControllerName %> from './<%= vars.ControllerName %>';
 
-export default class <%= serviceName %> {
-  static get<%= modulePascalNamePlural %> = (search: VovkControllerQuery<typeof <%= controllerName %>.get<%= modulePascalNamePlural %>>['search']) => {
+export default class <%= vars.ServiceName %> {
+  static get<%= t.TheThings %> = (search: VovkControllerQuery<typeof <%= vars.ControllerName %>.get<%= t.TheThings %>>['search']) => {
     return { results: [], search };
   };
 
-  static update<%= modulePascalName %> = (
+  static update<%= t.TheThing %> = (
     id: string,
-    q: VovkControllerQuery<typeof <%= controllerName %>.update<%= modulePascalName %>>['q'],
-    body: VovkControllerBody<typeof <%= controllerName %>.update<%= modulePascalName %>>
+    q: VovkControllerQuery<typeof <%= vars.ControllerName %>.update<%= t.TheThing %>>['q'],
+    body: VovkControllerBody<typeof <%= vars.ControllerName %>.update<%= t.TheThing %>>
   ) => {
     return { id, q, body };
   };