vovk-cli 0.0.1-draft.41 → 0.0.1-draft.43

package/client-templates/compiled/{client.d.ts.ejs → compiled.d.ts.ejs}

@@ -1,12 +1,13 @@
+
 <%- '// auto-generated\n/* eslint-disable */' %>
 import type { clientizeController, VovkClientFetcher } from 'vovk/client';
 import type { promisifyWorker } from 'vovk/worker';
 import type fetcher from '<%= fetcherClientImportPath %>';
-
-<% segments.forEach((segment, i) => { %>
-    import type { Controllers as Controllers<%= i %>, Workers as Workers<%= i %> } from "<%= segment.segmentImportPath %>";
+<% segments.forEach((segment, i) => { 
+  const hasWorkers = !!Object.keys(segmentsSchema[segment.segmentName].workers).length;
+%>
+import type { Controllers as Controllers<%= i %><% if(hasWorkers) { %>, Workers as Workers<%= i %> <% } %> } from "<%= segment.segmentImportPath %>";
 <% }) %>
-
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
 
 <% segments.forEach((segment, i) => {
@@ -16,9 +17,9 @@ type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
     const workers     = Object.keys(segSchema.workers);
 %>
   <% controllers.forEach((key) => { %>
-    export const <%= key %>: ReturnType<typeof clientizeController<Controllers<%= i %>["<%= key %>"], Options>>;
+export const <%= key %>: ReturnType<typeof clientizeController<Controllers<%= i %>["<%= key %>"], Options>>;
   <% }) %>
   <% workers.forEach((key) => { %>
-    export const <%= key %>: ReturnType<typeof promisifyWorker<Workers<%= i %>["<%= key %>"]>>;
+export const <%= key %>: ReturnType<typeof promisifyWorker<Workers<%= i %>["<%= key %>"]>>;
   <% }) %>
 <% }) %>

package/client-templates/compiled/{client.js.ejs → compiled.js.ejs}

@@ -5,7 +5,7 @@ const { default: fetcher } = require('<%= fetcherClientImportPath %>');
 const schema = require('<%= schemaOutImportPath %>');
 
 const { default: validateOnClient = null } = <%- validateOnClientImportPath ? `require('${validateOnClientImportPath}')` : '{}'%>;
-const apiRoot = '<%= apiEntryPoint %>';
+const apiRoot = '<%= apiRoot %>';
 
 <% segments.forEach((segment) => {
     const segSchema = segmentsSchema[segment.segmentName];
@@ -14,13 +14,13 @@ const apiRoot = '<%= apiEntryPoint %>';
     const workers     = Object.keys(segSchema.workers);
 %>
   <% controllers.forEach((key) => { %>
-    exports.<%= key %> = clientizeController(
-    schema['<%= segment.segmentName %>'].controllers.<%= key %>, 
-    '<%= segment.segmentName %>', 
-    { fetcher, validateOnClient, defaultOptions: { apiRoot } }
-    );
+exports.<%= key %> = clientizeController(
+  schema['<%= segment.segmentName %>'].controllers.<%= key %>, 
+  '<%= segment.segmentName %>', 
+  { fetcher, validateOnClient, defaultOptions: { apiRoot } }
+);
   <% }) %>
   <% workers.forEach((key) => { %>
-    exports.<%= key %> = promisifyWorker(null, schema['<%= segment.segmentName %>'].workers.<%= key %>);
+exports.<%= key %> = promisifyWorker(null, schema['<%= segment.segmentName %>'].workers.<%= key %>);
   <% }) %>
 <% }) %>

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

@@ -1,36 +1,35 @@
 <%- '// auto-generated\n/* eslint-disable */' %>
 import { clientizeController, type VovkClientFetcher } from 'vovk/client';
-import { promisifyWorker } from 'vovk/worker';
+<% if(hasWorkers) { %>import { promisifyWorker } from 'vovk/worker';<% } %>
 import fetcher from '<%= fetcherClientImportPath %>';
 import schema from '<%= schemaOutImportPath %>';
-
 <% if (validateOnClientImportPath) { %>
 import validateOnClient from '<%= validateOnClientImportPath %>';
 <% } else { %>
 const validateOnClient = undefined;
 <% } %>
-
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
-const apiRoot = '<%= apiEntryPoint %>';
+const apiRoot = '<%= apiRoot %>';
 
 <% segments.forEach((segment, i) => {
     const segSchema = segmentsSchema[segment.segmentName];
     if (!segSchema || !segSchema.emitSchema) return;
+    const hasWorkers = !!Object.keys(segmentsSchema[segment.segmentName].workers).length;
 %>
-  import type { Controllers as Controllers<%= i %>, Workers as Workers<%= i %> } from "<%= segment.segmentImportPath %>";
+import type { Controllers as Controllers<%= i %><% if(hasWorkers) { %>, Workers as Workers<%= i %> <% } %>} from "<%= segment.segmentImportPath %>";
 
   <% Object.keys(segSchema.controllers).forEach((key) => { %>
-    export const <%= key %> = clientizeController<Controllers<%= i %>["<%= key %>"], Options>(
-      schema['<%= segment.segmentName %>'].controllers.<%= key %>, 
-      '<%= segment.segmentName %>', 
-      { fetcher, validateOnClient, defaultOptions: { apiRoot } }
-    );
+export const <%= key %> = clientizeController<Controllers<%= i %>["<%= key %>"], Options>(
+  schema['<%= segment.segmentName %>'].controllers.<%= key %>, 
+  '<%= segment.segmentName %>', 
+  { fetcher, validateOnClient, defaultOptions: { apiRoot } }
+);
   <% }) %>
 
   <% Object.keys(segSchema.workers).forEach((key) => { %>
-    export const <%= key %> = promisifyWorker<Workers<%= i %>["<%= key %>"]>(
-      null, 
-      schema['<%= segment.segmentName %>'].workers.<%= key %>
-    );
+export const <%= key %> = promisifyWorker<Workers<%= i %>["<%= key %>"]>(
+  null, 
+  schema['<%= segment.segmentName %>'].workers.<%= key %>
+);
   <% }) %>
 <% }) %>

package/dist/dev/diffSchema.d.mts

@@ -1,5 +1,5 @@
 import type { VovkSchema } from 'vovk';
-import type { _VovkControllerSchema, _VovkWorkerSchema } from 'vovk/types';
+import type { VovkControllerSchema, VovkWorkerSchema } from 'vovk/types';
 interface HandlersDiff {
     nameOfClass: string;
     added: string[];
@@ -15,7 +15,7 @@ export interface DiffResult {
     workers: WorkersOrControllersDiff;
     controllers: WorkersOrControllersDiff;
 }
-export declare function diffHandlers<T extends _VovkWorkerSchema['handlers'] | _VovkControllerSchema['handlers']>(oldHandlers: T, newHandlers: T, nameOfClass: string): HandlersDiff;
+export declare function diffHandlers<T extends VovkWorkerSchema['handlers'] | VovkControllerSchema['handlers']>(oldHandlers: T, newHandlers: T, nameOfClass: string): HandlersDiff;
 export declare function diffWorkersOrControllers<T extends VovkSchema['controllers'] | VovkSchema['workers']>(oldItems: T, newItems: T): WorkersOrControllersDiff;
 /**
 example output:

package/dist/dev/ensureClient.d.mts

@@ -1,5 +1,5 @@
 import type { ProjectInfo } from '../getProjectInfo/index.mjs';
-export default function ensureClient(projectInfo: ProjectInfo): Promise<{
+export default function ensureClient({ config, cwd, log }: ProjectInfo): Promise<{
     written: boolean;
     path: string;
 }>;

package/dist/dev/ensureClient.mjs

@@ -1,7 +1,6 @@
 import path from 'node:path';
 import fs from 'node:fs/promises';
-export default async function ensureClient(projectInfo) {
-    const { config, cwd, log } = projectInfo;
+export default async function ensureClient({ config, cwd, log }) {
     const now = Date.now();
     const clientoOutDirAbsolutePath = path.join(cwd, config.clientOutDir);
     const dts = `// auto-generated
@@ -10,8 +9,8 @@ export default async function ensureClient(projectInfo) {
 // Feel free to report an issue at https://github.com/finom/vovk/issues`;
     const js = dts;
     const ts = dts;
-    const localJsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'client.js');
-    const localDtsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'client.d.ts');
+    const localJsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'compiled.js');
+    const localDtsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'compiled.d.ts');
     const localTsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'index.ts');
     const existingJs = await fs.readFile(localJsAbsolutePath, 'utf-8').catch(() => null);
     const existingDts = await fs.readFile(localDtsAbsolutePath, 'utf-8').catch(() => null);

package/dist/dev/index.mjs

@@ -11,7 +11,7 @@ import writeOneSchemaFile from './writeOneSchemaFile.mjs';
 import logDiffResult from './logDiffResult.mjs';
 import ensureClient from './ensureClient.mjs';
 import getProjectInfo from '../getProjectInfo/index.mjs';
-import generateClient from '../generateClient.mjs';
+import generate from '../generate/index.mjs';
 import locateSegments from '../locateSegments.mjs';
 import debounceWithArgs from '../utils/debounceWithArgs.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
@@ -215,9 +215,9 @@ export class VovkDev {
         }
     };
     #requestSchema = debounceWithArgs(async (segmentName) => {
-        const { apiEntryPoint, log, port, config } = this.#projectInfo;
+        const { apiRoot, log, port, config } = this.#projectInfo;
         const { devHttps } = config;
-        const endpoint = `${apiEntryPoint.startsWith(`http${devHttps ? 's' : ''}://`) ? apiEntryPoint : `http${devHttps ? 's' : ''}://localhost:${port}${apiEntryPoint}`}/${segmentName ? `${segmentName}/` : ''}_schema_`;
+        const endpoint = `${apiRoot.startsWith(`http${devHttps ? 's' : ''}://`) ? apiRoot : `http${devHttps ? 's' : ''}://localhost:${port}${apiRoot}`}/${segmentName ? `${segmentName}/` : ''}_schema_`;
         log.debug(`Requesting schema for ${formatLoggedSegmentName(segmentName)} at ${endpoint}`);
         try {
             const resp = await fetch(endpoint);
@@ -275,7 +275,7 @@ export class VovkDev {
         }
         if (this.#segments.every((s) => this.#schemas[s.segmentName])) {
             log.debug(`All segments with "emitSchema" have schema.`);
-            await generateClient({ projectInfo: this.#projectInfo, segments: this.#segments, segmentsSchema: this.#schemas });
+            await generate({ projectInfo: this.#projectInfo, segments: this.#segments, segmentsSchema: this.#schemas });
         }
     }
     async start() {

package/dist/generate/getClientTemplates.d.mts

@@ -0,0 +1,11 @@
+import { VovkConfig } from "../types.mjs";
+interface ClientTemplate {
+    templatePath: string;
+    outPath: string;
+}
+export default function getClientTemplates({ config, cwd, templateNames, }: {
+    config: Required<VovkConfig>;
+    cwd: string;
+    templateNames?: string[];
+}): ClientTemplate[];
+export {};

package/dist/generate/getClientTemplates.mjs

@@ -0,0 +1,25 @@
+import path from 'node:path';
+export default function getClientTemplates({ config, cwd, templateNames = [], }) {
+    const __dirname = path.dirname(new URL(import.meta.url).pathname);
+    const templatesDir = path.join(__dirname, '../..', 'client-templates');
+    const clientOutDirAbsolutePath = path.resolve(cwd, config.clientOutDir);
+    const mapper = (dir) => (name) => ({
+        templatePath: path.resolve(templatesDir, dir, name),
+        outPath: path.join(clientOutDirAbsolutePath, name.replace('.ejs', '')),
+    });
+    const builtInTemplatesMap = {
+        ts: ['index.ts.ejs'].map(mapper('ts')),
+        compiled: ['compiled.js.ejs', 'compiled.d.ts.ejs'].map(mapper('compiled')),
+        python: ['__init__.py'].map(mapper('python')),
+    };
+    const templateFiles = (templateNames ?? config.clientGenerateTemplateNames).reduce((acc, template) => {
+        if (template in builtInTemplatesMap) {
+            return [...acc, ...builtInTemplatesMap[template]];
+        }
+        return [...acc, {
+                templatePath: path.resolve(cwd, template),
+                outPath: path.join(clientOutDirAbsolutePath, path.basename(template).replace('.ejs', ''))
+            }];
+    }, []);
+    return templateFiles;
+}

package/dist/generate/index.d.mts

@@ -0,0 +1,12 @@
+import type { VovkSchema } from 'vovk';
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+import type { Segment } from '../locateSegments.mjs';
+import { GenerateOptions } from '../types.mjs';
+export default function generate({ projectInfo, segments, segmentsSchema, templates, prettify: prettifyClient, fullSchema, }: {
+    projectInfo: ProjectInfo;
+    segments: Segment[];
+    segmentsSchema: Record<string, VovkSchema>;
+} & Pick<GenerateOptions, 'templates' | 'prettify' | 'fullSchema'>): Promise<{
+    written: boolean;
+    path: string;
+}>;

package/dist/{generateClient.mjs → generate/index.mjs}

@@ -1,31 +1,15 @@
 import path from 'node:path';
 import fs from 'node:fs/promises';
 import ejs from 'ejs';
-import formatLoggedSegmentName from './utils/formatLoggedSegmentName.mjs';
-import prettify from './utils/prettify.mjs';
-export default async function generateClient({ projectInfo, segments, segmentsSchema, templates = ['ts', 'compiled'], prettify: prettifyClient, fullSchema, noClient, }) {
-    const { config, cwd, log, validateOnClientImportPath, apiEntryPoint, fetcherClientImportPath, schemaOutImportPath, } = projectInfo;
-    const __dirname = path.dirname(new URL(import.meta.url).pathname);
-    const templatesDir = path.join(__dirname, '..', 'client-templates');
+import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
+import prettify from '../utils/prettify.mjs';
+import getClientTemplates from './getClientTemplates.mjs';
+export default async function generate({ projectInfo, segments, segmentsSchema, templates, prettify: prettifyClient, fullSchema, }) {
+    templates = templates ?? projectInfo.config.clientGenerateTemplateNames;
+    const noClient = templates?.[0] === 'none';
+    const { config, cwd, log, validateOnClientImportPath, apiRoot, fetcherClientImportPath, schemaOutImportPath, } = projectInfo;
     const clientOutDirAbsolutePath = path.resolve(cwd, config.clientOutDir);
-    const mapper = (dir) => (name) => ({
-        templatePath: path.resolve(templatesDir, dir, name),
-        outPath: path.join(clientOutDirAbsolutePath, name.replace('.ejs', '')),
-    });
-    const builtInTemplatesMap = {
-        ts: ['index.ts.ejs'].map(mapper('ts')),
-        compiled: ['client.js.ejs', 'client.d.ts.ejs'].map(mapper('compiled')),
-        python: ['__init__.py'].map(mapper('python')),
-    };
-    const templateFiles = templates.reduce((acc, template) => {
-        if (template in builtInTemplatesMap) {
-            return [...acc, ...builtInTemplatesMap[template]];
-        }
-        return [...acc, {
-                templatePath: path.resolve(cwd, template),
-                outPath: path.join(clientOutDirAbsolutePath, path.basename(template).replace('.ejs', ''))
-            }];
-    }, []);
+    const templateFiles = getClientTemplates({ config, cwd, templateNames: templates });
     // Ensure that each segment has a matching schema if it needs to be emitted:
     for (let i = 0; i < segments.length; i++) {
         const { segmentName } = segments[i];
@@ -39,7 +23,7 @@ export default async function generateClient({ projectInfo, segments, segmentsSc
     const now = Date.now();
     // Data for the EJS templates:
     const ejsData = {
-        apiEntryPoint,
+        apiRoot,
         fetcherClientImportPath,
         schemaOutImportPath,
         validateOnClientImportPath,
@@ -69,7 +53,7 @@ export default async function generateClient({ projectInfo, segments, segmentsSc
     if (fullSchema) {
         const fullSchemaOutAbsolutePath = path.resolve(clientOutDirAbsolutePath, typeof fullSchema === 'string' ? fullSchema : 'full-schema.json');
         await fs.writeFile(fullSchemaOutAbsolutePath, JSON.stringify(segmentsSchema, null, 2));
-        log.info(`Full schema written to ${fullSchemaOutAbsolutePath}`);
+        log.info(`Full schema has ben written to ${fullSchemaOutAbsolutePath}`);
     }
     // 2. Check if any file needs rewriting
     const anyNeedsWriting = processedTemplates.some(({ needsWriting }) => needsWriting);

package/dist/getProjectInfo/getConfig.mjs

@@ -18,6 +18,7 @@ export default async function getConfig({ clientOutDir, cwd }) {
         logLevel: env.VOVK_LOG_LEVEL ?? conf.logLevel ?? 'info',
         prettifyClient: (env.VOVK_PRETTIFY_CLIENT ? !!env.VOVK_PRETTIFY_CLIENT : null) ?? conf.prettifyClient ?? false,
         devHttps: (env.VOVK_DEV_HTTPS ? !!env.VOVK_DEV_HTTPS : null) ?? conf.devHttps ?? false,
+        clientGenerateTemplateNames: conf.clientGenerateTemplateNames ?? ['compiled'],
         templates: {
             service: 'vovk-cli/templates/service.ejs',
             controller: 'vovk-cli/templates/controller.ejs',

package/dist/getProjectInfo/index.d.mts

@@ -6,7 +6,7 @@ export default function getProjectInfo({ port: givenPort, clientOutDir, cwd, }?:
 }): Promise<{
     cwd: string;
     port: string;
-    apiEntryPoint: string;
+    apiRoot: string;
     apiDir: string;
     srcRoot: string;
     schemaOutImportPath: string;

package/dist/getProjectInfo/index.mjs

@@ -6,7 +6,7 @@ export default async function getProjectInfo({ port: givenPort, clientOutDir, cw
     // Make PORT available to the config file at getConfig
     process.env.PORT = port;
     const { config, srcRoot, configAbsolutePaths, userConfig, error } = await getConfig({ clientOutDir, cwd });
-    const apiEntryPoint = `${config.origin ?? ''}/${config.rootEntry}`;
+    const apiRoot = `${config.origin ?? ''}/${config.rootEntry}`;
     const apiDir = path.join(srcRoot, 'app', config.rootEntry);
     const schemaOutImportPath = path.relative(config.clientOutDir, config.schemaOutDir).replace(/\\/g, '/'); // windows fix
     const fetcherClientImportPath = config.fetcher.startsWith('.')
@@ -25,7 +25,7 @@ export default async function getProjectInfo({ port: givenPort, clientOutDir, cw
     return {
         cwd,
         port,
-        apiEntryPoint,
+        apiRoot,
         apiDir,
         srcRoot,
         schemaOutImportPath,

package/dist/index.mjs

@@ -7,7 +7,7 @@ import { Command } from 'commander';
 import concurrently from 'concurrently';
 import getAvailablePort from './utils/getAvailablePort.mjs';
 import getProjectInfo from './getProjectInfo/index.mjs';
-import generateClient from './generateClient.mjs';
+import generate from './generate/index.mjs';
 import locateSegments from './locateSegments.mjs';
 import { VovkDev } from './dev/index.mjs';
 import newComponents from './new/index.mjs';
@@ -66,19 +66,18 @@ program
     .alias('g')
     .description('Generate client')
     .option('--out, --client-out-dir <path>', 'Path to output directory')
-    .option('--template, --templates <templates...>', 'Client code templates')
-    .option('--no-client', 'Do not generate client')
+    .option('--template, --templates <templates...>', 'Client code templates ("ts", "compiled", "python", "none", a custom path)')
     .option('--full-schema [fileName]', 'Generate client with full schema')
     .option('--prettify', 'Prettify output files')
     .action(async (options) => {
-    const { clientOutDir, templates, prettify, noClient, fullSchema } = options;
+    const { clientOutDir, templates, prettify, fullSchema } = options;
     const projectInfo = await getProjectInfo({ clientOutDir });
     const { cwd, config, apiDir } = projectInfo;
     const segments = await locateSegments({ dir: apiDir, config });
     const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
     const schemaImportUrl = pathToFileURL(path.join(schemaOutAbsolutePath, 'index.js')).href;
     const { default: segmentsSchema } = await import(schemaImportUrl);
-    await generateClient({ projectInfo, segments, segmentsSchema, templates, prettify, noClient, fullSchema });
+    await generate({ projectInfo, segments, segmentsSchema, templates, prettify, fullSchema });
 });
 program
     .command('new [components...]')

package/dist/postinstall.mjs

@@ -7,9 +7,9 @@ import path from 'node:path';
  */
 const getFileSystemEntryType = async (filePath) => !!(await fs.stat(filePath).catch(() => false));
 async function postinstall() {
-    const vovk = path.join(import.meta.dirname, '../../.vovk');
-    const js = path.join(vovk, 'client.js');
-    const ts = path.join(vovk, 'client.d.ts');
+    const vovk = path.join(import.meta.dirname, '../../.vovk-client');
+    const js = path.join(vovk, 'compiled.js');
+    const ts = path.join(vovk, 'compiled.d.ts');
     const index = path.join(vovk, 'index.ts');
     if ((await getFileSystemEntryType(js)) ||
         (await getFileSystemEntryType(ts)) ||

package/dist/types.d.mts

@@ -30,6 +30,7 @@ export type VovkConfig = {
     logLevel?: LogLevelNames;
     prettifyClient?: boolean;
     devHttps?: boolean;
+    clientGenerateTemplateNames?: string[];
     templates?: {
         service?: string;
         controller?: string;
@@ -52,7 +53,6 @@ export interface GenerateOptions {
     templates?: string[];
     prettify?: boolean;
     fullSchema?: string | boolean;
-    noClient?: boolean;
 }
 export interface InitOptions {
     yes?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.41",
+  "version": "0.0.1-draft.43",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
@@ -36,7 +36,7 @@
   },
   "homepage": "https://vovk.dev",
   "peerDependencies": {
-    "vovk": "^3.0.0-draft.34"
+    "vovk": "^3.0.0-draft.35"
   },
   "dependencies": {
     "@inquirer/prompts": "^7.1.0",

package/dist/generateClient.d.mts

@@ -1,12 +0,0 @@
-import type { VovkSchema } from 'vovk';
-import type { ProjectInfo } from './getProjectInfo/index.mjs';
-import type { Segment } from './locateSegments.mjs';
-import { GenerateOptions } from './types.mjs';
-export default function generateClient({ projectInfo, segments, segmentsSchema, templates, prettify: prettifyClient, fullSchema, noClient, }: {
-    projectInfo: ProjectInfo;
-    segments: Segment[];
-    segmentsSchema: Record<string, VovkSchema>;
-} & Pick<GenerateOptions, 'templates' | 'prettify' | 'fullSchema' | 'noClient'>): Promise<{
-    written: boolean;
-    path: string;
-}>;