vovk-cli 0.0.1-draft.38 → 0.0.1-draft.381

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023-present Andrii Gubanov
+Copyright (c) 2023-present Andrey Gubanov
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1 +1,31 @@
-Description is coming soon.
+<p align="center">
+  <a href="https://vovk.dev">
+    <picture>
+      <source width="300" media="(prefers-color-scheme: dark)" srcset="https://vovk.dev/vovk-logo-white.svg">
+      <source width="300" media="(prefers-color-scheme: light)" srcset="https://vovk.dev/vovk-logo.svg">
+      <img width="300" alt="vovk" src="https://vovk.dev/vovk-logo.svg">
+    </picture>
+  </a>
+  <br>
+  <strong>Back-end for <a href="https://nextjs.org/">Next.js</a></strong>
+</p>
+
+---
+
+## vovk-cli [![npm version](https://badge.fury.io/js/vovk-cli.svg)](https://www.npmjs.com/package/vovk-cli)
+
+The Vovk.ts [CLI](https://vovk.dev/cli) that will be used as a devDependency in a Vovk.ts app.
+
+```sh
+npm install -D vovk-cli
+```
+
+- [vovk dev](https://vovk.dev/dev) - starts the development script that watches the changes in [controllers](https://vovk.dev/controller) and regenerates the [schema](https://vovk.dev/schema) and [client](https://vovk.dev/typescript).
+- [vovk generate](https://vovk.dev/generate) - generates the client based on the schema.
+- [vovk bundle](https://vovk.dev/bundle) - bundles the client with [tsdown](https://tsdown.dev/).
+- [vovk init](https://vovk.dev/init) - initializes Vovk.ts project.
+- [vovk new](https://vovk.dev/new) - generates a new controller, service or a custom module.
+
+```sh
+npx vovk-cli --help
+```

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

@@ -0,0 +1,19 @@
+<%- t.getFirstLineBanner() %>
+const { createRPC } = require('<%= t.commonImports.createRPC %>');
+const { schema } = require('./schema.cjs');
+const { openapi } = require('./openapi.cjs');
+<% Object.entries(t.reExports).forEach(([reExportWhatCommaDivisible, reExportFrom]) => {
+    reExportWhatCommaDivisible.split(/\s*,\s*/).forEach((reExportWhat) => { %>
+exports['<%= reExportWhat.split(/\s+as\s+/)[1] ?? reExportWhat %>'] = require('<%= reExportFrom %>')['<%= reExportWhat.split(/\s+as\s+/)[0] %>'];
+  <% })
+}) %>
+<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema).forEach((segment) => { %>
+  <% Object.keys(segment.controllers).forEach((rpcModuleName) => { %>
+exports.<%= rpcModuleName %> = createRPC(
+  schema, '<%= segment.segmentName %>', '<%= rpcModuleName %>', require('<%= t.segmentImports[segment.segmentName].fetcher %>').fetcher,
+  { validateOnClient: <%- t.segmentImports[segment.segmentName].validateOnClient ? `require('${t.segmentImports[segment.segmentName].validateOnClient}').validateOnClient` : 'undefined' %>, <%- typeof t.segmentMeta[segment.segmentName].segmentNameOverride === 'string' ? `segmentNameOverride: '${t.segmentMeta[segment.segmentName].segmentNameOverride}', ` : '' %><%- segment.segmentType === 'mixin' ? '' : `apiRoot: '${t.segmentMeta[segment.segmentName].forceApiRoot ?? t.apiRoot}'` %> }
+);
+  <% })
+}) %>
+exports.schema = schema;
+exports.openapi = openapi;

package/client-templates/cjs/index.d.cts.ejs

@@ -0,0 +1,22 @@
+<%- t.getFirstLineBanner() %>
+import type { VovkFetcher } from 'vovk';
+import type { createRPC } from '<%= t.commonImports.module.createRPC %>';
+<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { if(segment.segmentType !== 'mixin') { %>
+import type { Controllers as Controllers<%= i %> } from "<%= t.segmentMeta[segment.segmentName].segmentImportPath %>";
+<% }}) %>
+<% if (t.hasMixins) { %>
+import type { Controllers as MixinControllers, Mixins } from "./mixins";
+<% } %>
+<% Object.entries(t.reExports).forEach(([reExportWhat, reExportFrom]) => { %>
+export { <%= reExportWhat %> } from '<%= reExportFrom %>';
+<% }) %>
+<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { %>
+  <% Object.keys(segment.controllers).forEach((rpcModuleName) => { %>
+export const <%= rpcModuleName %>: ReturnType<typeof createRPC<<%= segment.segmentType === 'mixin' ? `MixinControllers` : `Controllers${i}` %>["<%= rpcModuleName %>"], typeof import('<%- t.segmentImports[segment.segmentName].module.fetcher %>').fetcher extends VovkFetcher<infer U> ? U : never>>;
+  <% }) 
+}) %>
+export { schema } from './schema.cjs';
+export { openapi } from './openapi.cjs';
+<% if (t.hasMixins) { %>
+export { Mixins };
+<% } %>

package/client-templates/mixins/mixins.d.ts.ejs

@@ -0,0 +1,64 @@
+<%- t.getFirstLineBanner() %>
+import type { VovkRequest, VovkStreamAsyncIterable, KnownAny } from 'vovk';
+
+<% const mixins = Object.values(t.schema.segments).filter((segment) => segment.emitSchema && segment.segmentType === 'mixin'); %>
+
+export namespace Mixins {
+  <% for (const segment of mixins) { %>
+    <% if(segment.meta?.openAPIObject?.components?.schemas) { %>
+      export namespace <%= t._.upperFirst(t._.camelCase(segment.segmentName)) %> {
+        <% for (const [componentName, componentSchema] of Object.entries(segment.meta.openAPIObject.components.schemas)) { %>
+          <%- t.compileJSONSchemaToTypeScriptType(componentSchema, componentName, segment.meta.openAPIObject.components, { dontCreateRefTypes: true }) %>
+        <% } %>
+      }
+    <% } %>
+  <% } %>
+}
+
+export namespace Types {
+  <% for (const segment of mixins) { %>
+    export namespace <%= t._.upperFirst(t._.camelCase(segment.segmentName)) %> {
+      <% for (const [controllerName, controllerSchema] of Object.entries(segment.controllers)) { %>
+        export namespace <%= controllerSchema.rpcModuleName %> {
+          <% for (const [handlerName, handlerSchema] of Object.entries(controllerSchema.handlers)) { %>
+            export namespace <%= t._.upperFirst(handlerName) %> {
+            <%- t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.body, 'Body') %>
+            <%- t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.query, 'Query') %>
+            <%- t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.params, 'Params') %>
+            <%- t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.output, 'Output') %>
+            <%- t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.iteration,  'Iteration') %>
+            }
+          <% } %>
+        }
+      <% } %>
+    }
+  <% } %>
+}
+
+<% const getType = (segment, controllerSchema, handlerName, validationType) => {
+  const segmentNs = t._.upperFirst(t._.camelCase(segment.segmentName));
+  const controllerNs = controllerSchema.rpcModuleName;
+  const handlerNs = t._.upperFirst(handlerName);
+  const typeName = t._.upperFirst(validationType);
+  const handlerSchema = controllerSchema.handlers[handlerName];
+  if(handlerSchema.validation?.[validationType] ) {
+    return 'Types.' + segmentNs + '.' + controllerNs + '.' + handlerNs + '.' + typeName;
+  }
+  return 'null';
+} %>
+
+export type Controllers = {
+    <% for (const segment of Object.values(t.schema.segments).filter((segment) => segment.emitSchema && segment.segmentType === 'mixin')) { %>
+      <% for (const controllerSchema of Object.values(segment.controllers)) { %>
+      <%= controllerSchema.rpcModuleName %>: {
+        <% for (const [handlerName, handlerSchema] of Object.entries(controllerSchema.handlers)) { %>
+          <%= handlerName %>: (req: VovkRequest<
+          <%- getType(segment, controllerSchema, handlerName, 'body') %>, 
+          <%- getType(segment, controllerSchema, handlerName, 'query') %>, 
+          <%- getType(segment, controllerSchema, handlerName, 'params')  %>
+          >) => <%- handlerSchema.validation?.output ? `Promise<${getType(segment, controllerSchema, handlerName, 'output')}>` : handlerSchema.validation?.iteration ? `Promise<VovkStreamAsyncIterable<${getType(segment, controllerSchema, handlerName, 'iteration')}>>` : 'Promise<KnownAny>' %>,
+        <% } %>
+      };
+     <% } %>
+    <% } %>
+};

package/client-templates/mixins/mixins.json.ejs

@@ -0,0 +1 @@
+<%- JSON.stringify(t._.pickBy(t.schema.segments, (segment) => segment.segmentType === 'mixin'), null, 2) %>

package/client-templates/mjs/index.d.mts.ejs

@@ -0,0 +1,22 @@
+<%- t.getFirstLineBanner() %>
+import type { VovkFetcher } from 'vovk';
+import type { createRPC } from '<%= t.commonImports.module.createRPC %>';
+<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { if(segment.segmentType !== 'mixin') { %>
+import type { Controllers as Controllers<%= i %> } from "<%= t.segmentMeta[segment.segmentName].segmentImportPath %>";
+<% }}) %>
+<% if (t.hasMixins) { %>
+import type { Controllers as MixinControllers, Mixins } from "./mixins";
+<% } %>
+<% Object.entries(t.reExports).forEach(([reExportWhat, reExportFrom]) => { %>
+export { <%= reExportWhat %> } from '<%= reExportFrom %>';
+<% }) %>
+<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { %>
+  <% Object.keys(segment.controllers).forEach((rpcModuleName) => { %>
+export const <%= rpcModuleName %>: ReturnType<typeof createRPC<<%= segment.segmentType === 'mixin' ? `MixinControllers` : `Controllers${i}` %>["<%= rpcModuleName %>"], typeof import('<%- t.segmentImports[segment.segmentName].module.fetcher %>').fetcher extends VovkFetcher<infer U> ? U : never>>;
+  <% }) 
+}) %>
+export { schema } from './schema.cjs';
+export { openapi } from './openapi.cjs';
+<% if (t.hasMixins) { %>
+export { Mixins };
+<% } %>

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

@@ -0,0 +1,18 @@
+<%- t.getFirstLineBanner() %>
+import { createRPC } from '<%= t.commonImports.module.createRPC %>';
+import { schema } from './schema.cjs';
+import { openapi } from './openapi.cjs';
+<% Object.entries(t.reExports).forEach(([reExportWhat, reExportFrom]) => { %>
+export { <%= reExportWhat %> } from '<%= reExportFrom %>';
+<% }) %>
+<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { %>
+  <% Object.keys(segment.controllers).forEach((rpcModuleName) => { %>
+export const <%= rpcModuleName %> = createRPC(
+  schema, '<%= segment.segmentName %>', '<%= rpcModuleName %>', import('<%- t.segmentImports[segment.segmentName].module.fetcher %>'),
+  { validateOnClient: <%- t.segmentImports[segment.segmentName].module.validateOnClient ? `import('${t.segmentImports[segment.segmentName].validateOnClient}')` : 'undefined' %>, <%- typeof t.segmentMeta[segment.segmentName].segmentNameOverride === 'string' ? `segmentNameOverride: '${t.segmentMeta[segment.segmentName].segmentNameOverride}', ` : '' %><%- segment.segmentType === 'mixin' ? '' : `apiRoot: '${t.segmentMeta[segment.segmentName].forceApiRoot ?? t.apiRoot}'` %> }
+);
+<% 
+  }); 
+});
+%>
+export { schema, openapi };

package/client-templates/openapiCjs/openapi.cjs.ejs

@@ -0,0 +1,4 @@
+<%- t.getFirstLineBanner() %>
+const openapi = require('./openapi.json');
+
+module.exports.openapi = openapi;

package/client-templates/openapiCjs/openapi.d.cts.ejs

@@ -0,0 +1,4 @@
+<%- t.getFirstLineBanner() %>
+import type { OpenAPIObject } from 'openapi3-ts/oas31';
+
+export const openapi: OpenAPIObject;

package/client-templates/openapiJson/openapi.json.ejs

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

package/client-templates/openapiTs/openapi.ts.ejs

@@ -0,0 +1,4 @@
+<%- t.getFirstLineBanner() %>
+import openapi from './openapi.json' with { type: "json" };
+
+export { openapi };

package/client-templates/packageJson/package.json.ejs

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

package/client-templates/readme/README.md.ejs

@@ -0,0 +1,39 @@
+<%- t.getFirstLineBanner('html') %>
+<%- t.readme.banner %>
+
+# <%= t.package.name %> v<%= t.package.version %> [![TypeScript](https://badgen.net/badge/-/TypeScript?icon=typescript&label&labelColor=blue&color=555555)](https://www.typescriptlang.org/) [![Vovk.ts](https://badgen.net/badge/Built%20with/Vovk.ts/333333?icon=https://vovk.dev/icon-white.svg)](https://vovk.dev)
+
+<%- t.readme.description ?? (`${t.package.description ? `> ${t.package.description}` : ''}`) %>
+
+<%- t.package.license ? `License: **${t.package.license}**` : '' %>
+
+```bash
+# Install the package
+<%= t.readme.installCommand ?? `npm install ${t.package.name}` %>
+```
+
+<% Object.entries(t.schema.segments).forEach(([segmentName, segment]) => {
+    Object.values(segment.controllers).forEach((controllerSchema) => { %>
+
+## <%= controllerSchema.rpcModuleName %>
+        <% Object.entries(controllerSchema.handlers).forEach(([handlerName, handlerSchema]) => { %>
+### <%= controllerSchema.rpcModuleName %>.<%= handlerName %>
+<%- handlerSchema.operationObject?.summary ? `> ${handlerSchema.operationObject.summary}` : '' %>
+
+<%- handlerSchema.operationObject?.description ? `${handlerSchema.operationObject.description}` : '' %>
+
+<% const forceApiRoot = t.segmentMeta[segment.segmentName].forceApiRoot ?? controllerSchema.forceApiRoot; %>
+`<%= handlerSchema.httpMethod %> <%= [...(forceApiRoot ? [forceApiRoot] : [t.apiRoot, segmentName]), controllerSchema.prefix, handlerSchema.path].map((part, i) => i > 0 ? t._.trim(part, '/') : part).filter(Boolean).join('/') %>`
+
+```ts
+<%- t.createCodeSamples({
+    handlerSchema,
+    handlerName,
+    controllerSchema,
+    package: t.package,
+    config: t.samples,
+}).ts %>
+```
+        <% }) %>
+    <% }) %>
+<% }) %>

package/client-templates/schemaCjs/schema.cjs.ejs

@@ -0,0 +1,24 @@
+<%- t.getFirstLineBanner() %>
+<% if(t.isVovkProject) { %>
+const meta = require('./<%= t.schemaOutDir %>/_meta.json');
+<% } else { %>
+const meta = <%- JSON.stringify(t.publicMeta, null, 2) %>;
+<% } %>
+
+<% if(t.hasMixins) { %>
+const mixins = require('./mixins.json');
+<% } %>
+const segments = {<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema && segment.segmentType !== 'mixin').forEach((segment) => { %>
+    '<%= segment.segmentName %>': require('./<%= t.schemaOutDir %>/<%= segment.segmentName || t.ROOT_SEGMENT_FILE_NAME %>.json'),
+<% }) %>
+  <% if(t.hasMixins) { %>
+  ...mixins,
+  <% } %>
+};
+const schema = {
+  $schema: '<%- t.VovkSchemaIdEnum.SCHEMA %>',
+  segments,
+  meta,
+};
+
+module.exports.schema = schema;

package/client-templates/schemaCjs/schema.d.cts.ejs

@@ -0,0 +1,10 @@
+<%- t.getFirstLineBanner() %>
+import type { VovkMetaSchema, VovkSegmentSchema } from 'vovk';
+
+export const schema: {
+    $schema: '<%- t.VovkSchemaIdEnum.SCHEMA %>';
+    meta: VovkMetaSchema;
+    segments: {<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema).forEach((segment) => { %>
+      '<%= segment.segmentName %>': VovkSegmentSchema;<% }) %>
+    };
+};

package/client-templates/schemaJson/schema.json.ejs

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

package/client-templates/schemaTs/schema.ts.ejs

@@ -0,0 +1,28 @@
+<%- t.getFirstLineBanner() %>
+<% if(t.hasMixins) { %>
+import mixins from './mixins.json' with { type: "json" };
+import type { Mixins } from './mixins.d.ts';
+<% } %>
+<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema && segment.segmentType !== 'mixin').forEach((segment, i) => { %>
+import segment<%= i %> from './<%= t.schemaOutDir %>/<%= segment.segmentName || t.ROOT_SEGMENT_FILE_NAME %>.json' with { type: "json" };
+<% }); %>
+<% if(t.isVovkProject) { %>
+import meta from './<%= t.schemaOutDir %>/_meta.json' with { type: "json" };
+<% } else { %>
+const meta = <%- JSON.stringify(t.publicMeta, null, 2) %>;
+<% } %>
+const segments = {<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema && segment.segmentType !== 'mixin').forEach((segment, i) => { %>
+  '<%= segment.segmentName %>': segment<%= i %>,<% }) %>
+  <% if(t.hasMixins) { %>
+  ...mixins,
+  <% } %>
+};
+
+export const schema = {
+  $schema: '<%- t.VovkSchemaIdEnum.SCHEMA %>',
+  segments,
+  meta,
+};
+<% if (t.hasMixins) { %>
+export { Mixins };
+<% } %>

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

@@ -0,0 +1,27 @@
+<%- t.getFirstLineBanner() %>
+import type { VovkFetcher } from 'vovk';
+import { createRPC } from '<%= t.commonImports.module.createRPC %>';
+import { schema } from './schema<%= t.nodeNextResolutionExt.ts %>';
+import { openapi } from './openapi<%= t.nodeNextResolutionExt.ts %>';
+<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { if(segment.segmentType !== 'mixin') { %>
+import type { Controllers as Controllers<%= i %> } from "<%= t.segmentMeta[segment.segmentName].segmentImportPath %>";
+<% }
+});
+if (t.hasMixins) { %>
+import type { Controllers as MixinControllers, Mixins } from "./mixins.d.ts";
+<% } %>
+<% Object.entries(t.reExports).forEach(([reExportWhat, reExportFrom]) => { %>
+export { <%= reExportWhat %> } from '<%= reExportFrom %>';
+<% }) %>   
+<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => {  
+  Object.keys(segment.controllers).forEach((rpcModuleName) => { %>
+export const <%= rpcModuleName %> = createRPC<<%= segment.segmentType === 'mixin' ? `MixinControllers` : `Controllers${i}` %>["<%= rpcModuleName %>"], typeof import('<%- t.segmentImports[segment.segmentName].module.fetcher %>').fetcher extends VovkFetcher<infer U> ? U : never>(
+  schema, '<%= segment.segmentName %>', '<%= rpcModuleName %>', import('<%- t.segmentImports[segment.segmentName].module.fetcher %>'),
+  { validateOnClient: <%- t.segmentImports[segment.segmentName].module.validateOnClient ? `import('${t.segmentImports[segment.segmentName].validateOnClient}')` : 'undefined' %>, <%- typeof t.segmentMeta[segment.segmentName].segmentNameOverride === 'string' ? `segmentNameOverride: '${t.segmentMeta[segment.segmentName].segmentNameOverride}', ` : '' %><%- segment.segmentType === 'mixin' ? '' : `apiRoot: '${t.segmentMeta[segment.segmentName].forceApiRoot ?? t.apiRoot}'` %> }
+);
+<% }) 
+}) %>
+export { schema, openapi };
+<% if (t.hasMixins) { %>
+export { Mixins };
+<% } %>

package/dist/bundle/index.d.mts

@@ -0,0 +1,8 @@
+import type { VovkSchema } from 'vovk';
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+import type { BundleOptions } from '../types.mjs';
+export declare function bundle({ projectInfo, fullSchema, cliBundleOptions, }: {
+    projectInfo: ProjectInfo;
+    fullSchema: VovkSchema;
+    cliBundleOptions: BundleOptions;
+}): Promise<void>;

package/dist/bundle/index.mjs

@@ -0,0 +1,94 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import groupBy from 'lodash/groupBy.js';
+import { generate } from '../generate/generate.mjs';
+import { BuiltInTemplateName } from '../getProjectInfo/getConfig/getTemplateDefs.mjs';
+import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
+import { locateSegments } from '../locateSegments.mjs';
+/*
+async function tsdownBundle({
+  outDirAbsolute,
+  tsFullClientOutAbsoluteDirInput,
+}: {
+  outDirAbsolute: string;
+  tsFullClientOutAbsoluteDirInput: string;
+}) {
+  const { build } = await import('tsdown');
+
+  await build({
+    entry: path.join(tsFullClientOutAbsoluteDirInput, './index.ts'),
+    dts: true,
+    format: ['cjs', 'esm'],
+    hash: false,
+    fixedExtension: true,
+    clean: true,
+    ...tsdownBuildOptions,
+    outDir: outDirAbsolute,
+  });
+} */
+export async function bundle({ projectInfo, fullSchema, cliBundleOptions, }) {
+    const { config, log, cwd, apiDirAbsolutePath } = projectInfo;
+    const locatedSegments = await locateSegments({ dir: apiDirAbsolutePath, config, log });
+    const { bundle: bundleConfig } = config;
+    const keepPrebundleDir = cliBundleOptions?.keepPrebundleDir ?? bundleConfig?.keepPrebundleDir ?? false;
+    const prebundleOutDirAbsolute = path.resolve(cwd, cliBundleOptions?.prebundleOutDir ?? bundleConfig.prebundleOutDir);
+    const entry = path.join(prebundleOutDirAbsolute, 'index.ts');
+    const outDir = cliBundleOptions?.outDir ?? bundleConfig.outDir;
+    if (!outDir) {
+        throw new Error('No output directory specified for bundling');
+    }
+    const outDirAbsolute = path.resolve(cwd, outDir);
+    await generate({
+        isEnsuringClient: false,
+        isBundle: true,
+        projectInfo,
+        forceNothingWrittenLog: true,
+        fullSchema,
+        locatedSegments,
+        cliGenerateOptions: {
+            schemaPath: cliBundleOptions?.schemaPath,
+            origin: cliBundleOptions?.origin,
+            openapiSpec: cliBundleOptions?.openapiSpec,
+            openapiGetModuleName: cliBundleOptions?.openapiGetModuleName,
+            openapiGetMethodName: cliBundleOptions?.openapiGetMethodName,
+            openapiRootUrl: cliBundleOptions?.openapiRootUrl,
+            composedFrom: [BuiltInTemplateName.ts],
+            composedOut: prebundleOutDirAbsolute,
+            composedOnly: true,
+            composedIncludeSegments: cliBundleOptions.includeSegments ?? bundleConfig.includeSegments,
+            composedExcludeSegments: cliBundleOptions.excludeSegments ?? bundleConfig.excludeSegments,
+        },
+    });
+    log.debug(`Bundling ${chalkHighlightThing(entry)} to ${chalkHighlightThing(outDirAbsolute)}`);
+    await bundleConfig.build({
+        outDir: outDirAbsolute,
+        prebundleDir: prebundleOutDirAbsolute,
+        entry,
+    });
+    log.debug(`Bundled index.ts to ${chalkHighlightThing(outDirAbsolute)}`);
+    const requiresGroup = groupBy(Object.entries(bundleConfig.requires), ([, relativePath]) => relativePath);
+    for (const [relativePath, group] of Object.entries(requiresGroup)) {
+        await generate({
+            isEnsuringClient: false,
+            projectInfo,
+            forceNothingWrittenLog: true,
+            fullSchema,
+            locatedSegments,
+            cliGenerateOptions: {
+                schemaPath: cliBundleOptions?.schemaPath,
+                origin: cliBundleOptions?.origin,
+                composedFrom: group.map(([templateName]) => templateName),
+                composedOut: path.resolve(outDirAbsolute, relativePath),
+                composedOnly: true,
+            },
+        });
+    }
+    if (!keepPrebundleDir) {
+        await fs.rm(prebundleOutDirAbsolute, { recursive: true, force: true });
+        log.debug(`Deleted temporary TypeScript client output directory: ${chalkHighlightThing(prebundleOutDirAbsolute)}`);
+    }
+    else {
+        log.debug(`Temporary TypeScript client output directory not deleted because it is marked to keep: ${chalkHighlightThing(prebundleOutDirAbsolute)}`);
+    }
+    log.info(`Bundled TypeScript client to ${chalkHighlightThing(outDirAbsolute)}`);
+}

package/dist/dev/diffSegmentSchema.d.mts

@@ -0,0 +1,36 @@
+import type { VovkControllerSchema, VovkSegmentSchema } from 'vovk';
+interface HandlersDiff {
+    nameOfClass: string;
+    added: string[];
+    removed: string[];
+    changed: string[];
+}
+interface ControllersDiff {
+    added: string[];
+    removed: string[];
+    handlers: HandlersDiff[];
+}
+export interface DiffResult {
+    controllers: ControllersDiff;
+}
+export declare function diffHandlers<T extends VovkControllerSchema['handlers']>(oldHandlers: T, newHandlers: T, nameOfClass: string): HandlersDiff;
+export declare function diffControllers<T extends VovkSegmentSchema['controllers']>(oldItems: T, newItems: T): ControllersDiff;
+/**
+example output:
+{
+  controllers: {
+    added: ["ControllerC"],
+    removed: ["ControllerB"],
+    handlers: [
+      {
+        nameOfClass: "ControllerA",
+        added: ["handlerF"],
+        removed: [],
+        changed: ["handlerD"]
+      }
+    ]
+  }
+}
+*/
+export default function diffSegmentSchema(oldJson: VovkSegmentSchema, newJson: VovkSegmentSchema): DiffResult;
+export {};

package/dist/dev/{diffSchema.mjs → diffSegmentSchema.mjs}

@@ -18,7 +18,7 @@ export function diffHandlers(oldHandlers, newHandlers, nameOfClass) {
     }
     return { nameOfClass, added, removed, changed };
 }
-export function diffWorkersOrControllers(oldItems, newItems) {
+export function diffControllers(oldItems, newItems) {
     const added = [];
     const removed = [];
     const handlersDiff = [];
@@ -43,11 +43,6 @@ export function diffWorkersOrControllers(oldItems, newItems) {
 /**
 example output:
 {
-  workers: {
-    added: ["WorkerC"],
-    removed: ["WorkerA"],
-    handlers: []
-  },
   controllers: {
     added: ["ControllerC"],
     removed: ["ControllerB"],
@@ -62,11 +57,8 @@ example output:
   }
 }
 */
-export default function diffSchema(oldJson, newJson) {
-    const workersDiff = diffWorkersOrControllers(oldJson.workers ?? {}, newJson.workers ?? {});
-    const controllersDiff = diffWorkersOrControllers(oldJson.controllers ?? {}, newJson.controllers ?? {});
+export default function diffSegmentSchema(oldJson, newJson) {
     return {
-        workers: workersDiff,
-        controllers: controllersDiff,
+        controllers: diffControllers(oldJson.controllers ?? {}, newJson.controllers ?? {}),
     };
 }

package/dist/dev/ensureSchemaFiles.d.mts

@@ -1,3 +1,6 @@
 import { ProjectInfo } from '../getProjectInfo/index.mjs';
-export default function ensureSchemaFiles(projectInfo: ProjectInfo | null, schemaOutAbsolutePath: string, segmentNames: string[]): Promise<void>;
+/**
+ * Ensure that the schema files are created to avoid any import errors.
+ */
+export default function ensureSchemaFiles(projectInfo: ProjectInfo, schemaOutAbsolutePath: string, segmentNames: string[]): Promise<void>;
 export declare const debouncedEnsureSchemaFiles: import("lodash").DebouncedFunc<typeof ensureSchemaFiles>;

package/dist/dev/ensureSchemaFiles.mjs

@@ -1,44 +1,28 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import debounce from 'lodash/debounce.js';
-import writeOneSchemaFile, { ROOT_SEGMENT_SCHEMA_NAME } from './writeOneSchemaFile.mjs';
+import { VovkSchemaIdEnum } from 'vovk';
+import writeOneSegmentSchemaFile, { META_FILE_NAME, ROOT_SEGMENT_FILE_NAME } from './writeOneSegmentSchemaFile.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
+import writeMetaJson from './writeMetaJson.mjs';
+/**
+ * Ensure that the schema files are created to avoid any import errors.
+ */
 export default async function ensureSchemaFiles(projectInfo, schemaOutAbsolutePath, segmentNames) {
     const now = Date.now();
     let hasChanged = false;
-    // Create index.js file
-    const indexContent = `// auto-generated
-${segmentNames
-        .map((segmentName) => {
-        return `module.exports['${segmentName}'] = require('./${segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json');`;
-    })
-        .join('\n')}`;
-    const dTsContent = `// auto-generated
-import type { VovkSchema } from 'vovk';
-declare const segmentSchema: {
-${segmentNames.map((segmentName) => `  '${segmentName}': VovkSchema;`).join('\n')}
-};
-export default segmentSchema;`;
-    const jsAbsolutePath = path.join(schemaOutAbsolutePath, 'index.js');
-    const dTsAbsolutePath = path.join(schemaOutAbsolutePath, 'index.d.ts');
-    const existingJs = await fs.readFile(jsAbsolutePath, 'utf-8').catch(() => null);
-    const existingDTs = await fs.readFile(dTsAbsolutePath, 'utf-8').catch(() => null);
     await fs.mkdir(schemaOutAbsolutePath, { recursive: true });
-    if (existingJs !== indexContent) {
-        await fs.writeFile(jsAbsolutePath, indexContent);
-    }
-    if (existingDTs !== dTsContent) {
-        await fs.writeFile(dTsAbsolutePath, dTsContent);
-    }
+    await writeMetaJson(schemaOutAbsolutePath, projectInfo);
     // Create JSON files (if not exist) with name [segmentName].json (where segmentName can include /, which means the folder structure can be nested)
     await Promise.all(segmentNames.map(async (segmentName) => {
-        const { isCreated } = await writeOneSchemaFile({
+        const { isCreated } = await writeOneSegmentSchemaFile({
             schemaOutAbsolutePath,
-            schema: {
+            segmentSchema: {
+                $schema: VovkSchemaIdEnum.SEGMENT,
                 emitSchema: false,
                 segmentName,
+                segmentType: 'segment',
                 controllers: {},
-                workers: {},
             },
             skipIfExists: true,
         });
@@ -48,7 +32,7 @@ export default segmentSchema;`;
         }
     }));
     // Recursive function to delete unnecessary JSON files and folders
-    async function deleteUnnecessaryJsonFiles(dirPath) {
+    async function deleteUnnecessaryJsonFiles(dirPath, allow = [`${META_FILE_NAME}.json`]) {
         const entries = await fs.readdir(dirPath, { withFileTypes: true });
         await Promise.all(entries.map(async (entry) => {
             const absolutePath = path.join(dirPath, entry.name);
@@ -67,7 +51,8 @@ export default segmentSchema;`;
                 const relativePath = path.relative(schemaOutAbsolutePath, absolutePath);
                 const segmentName = relativePath.replace(/\\/g, '/').slice(0, -5); // Remove '.json' extension
                 if (!segmentNames.includes(segmentName) &&
-                    !segmentNames.includes(segmentName.replace(ROOT_SEGMENT_SCHEMA_NAME, ''))) {
+                    !segmentNames.includes(segmentName.replace(ROOT_SEGMENT_FILE_NAME, '')) &&
+                    !allow.includes(entry.name)) {
                     await fs.unlink(absolutePath);
                     projectInfo?.log.debug(`Deleted unnecessary schema file for ${formatLoggedSegmentName(segmentName)}`);
                     hasChanged = true;
@@ -75,9 +60,8 @@ export default segmentSchema;`;
             }
         }));
     }
-    // Start the recursive deletion from the root directory
     await deleteUnnecessaryJsonFiles(schemaOutAbsolutePath);
     if (hasChanged)
-        projectInfo?.log.info(`Schema files updated in ${Date.now() - now}ms`);
+        projectInfo?.log.info(`Created empty schema files in ${Date.now() - now}ms`);
 }
 export const debouncedEnsureSchemaFiles = debounce(ensureSchemaFiles, 1000);

package/dist/dev/index.d.mts

@@ -1,4 +1,8 @@
+import type { DevOptions } from '../types.mjs';
 export declare class VovkDev {
     #private;
-    start(): Promise<void>;
+    constructor({ schemaOut, devHttps, logLevel }: Pick<DevOptions, 'schemaOut' | 'devHttps' | 'logLevel'>);
+    start({ exit }: {
+        exit: boolean;
+    }): Promise<void>;
 }