vovk-cli 0.0.1-draft.98 → 0.0.1

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,29 +1,37 @@
-<p align="center"> 
-  <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><br>
-  <strong>REST + RPC = ♥️</strong>
-</p>
-
 <p align="center">
-  Back-end meta-framework for <a href="https://nextjs.org/docs/app">Next.js</a>
+  <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 Framework for Next.js App Router</strong>
+  <br />
+  <a href="https://vovk.dev/">Documentation</a>
+  &nbsp;&nbsp;
+  <a href="https://vovk.dev/quick-install">Quick Start</a>
+  &nbsp;&nbsp;
+  <a href="https://vovk.dev/performance">Performance</a>
 </p>
 
 ---
 
 ## vovk-cli [![npm version](https://badge.fury.io/js/vovk-cli.svg)](https://www.npmjs.com/package/vovk-cli)
 
-The Vovk.ts CLI that generates schema and client but also provides some useful utilities for the development process.
+Vovk.ts CLI that will be used as a devDependency in a Vovk.ts app.
 
 ```sh
 npm install -D vovk-cli
 ```
 
-- [vovk dev](https://vovk.dev/cli/vovk-dev) - starts the development script that watches the changes in controllers and regenerates the schema and client.
-- [vovk generate](https://vovk.dev/cli/vovk-generate) - generates the client based on the schema.
-- [vovk init](https://vovk.dev/cli/vovk-init) - initializes the Vovk.ts project.
-- [vovk new](https://vovk.dev/cli/vovk-new) - generates a new controller, service or a custom module.
+- [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 a new Vovk.ts project
+- [vovk new](https://vovk.dev/new) - generates a new controller, service or a custom module
 
-For more information, please visit the [CLI documentation](https://vovk.dev/cli) or use `npx vovk-cli --help` to get the list of available commands and options.
+```sh
+npx vovk-cli --help
+```

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

@@ -0,0 +1,21 @@
+<%- t.getFirstLineBanner() %>
+import type { VovkFetcher } from 'vovk/fetcher';
+import type { createRPC } from '<%= t.commonImports.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].fetcher %>').fetcher extends VovkFetcher<infer U> ? U : never>>;
+  <% }) 
+}) %>
+export { schema } from './schema.js';
+<% if (t.hasMixins) { %>
+export { Mixins };
+<% } %>

package/client-templates/jsBase/index.js.ejs

@@ -0,0 +1,18 @@
+<%- t.getFirstLineBanner() %>
+import { createRPC } from '<%= t.commonImports.createRPC %>';
+import { schema } from './schema.js';
+<% 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) => { 
+    const apiRoot = t.segmentMeta[segment.segmentName].forceApiRoot ?? t.apiRoot; %>
+export const <%= rpcModuleName %> = createRPC(
+  schema, '<%= segment.segmentName %>', '<%= rpcModuleName %>', import('<%- t.segmentImports[segment.segmentName].fetcher %>'),
+  { validateOnClient: <%- t.segmentImports[segment.segmentName].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 ? `apiRoot: '${apiRoot}'` : '' %> }
+);
+<% 
+  }); 
+});
+%>
+export { schema };

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/openapiJs/openapi.d.ts.ejs

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

package/client-templates/openapiJs/openapi.js.ejs

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

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/schemaJs/schema.d.ts.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/schemaJs/schema.js.ejs

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

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.schema.meta, 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/tsBase/index.ts.ejs

@@ -0,0 +1,27 @@
+<%- t.getFirstLineBanner() %>
+import type { VovkFetcher } from 'vovk/fetcher';
+import { createRPC } from '<%= t.commonImports.createRPC %>';
+import { schema } from './schema<%= 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) => { 
+    const apiRoot = t.segmentMeta[segment.segmentName].forceApiRoot ?? t.apiRoot; %>
+export const <%= rpcModuleName %> = createRPC<<%= segment.segmentType === 'mixin' ? `MixinControllers` : `Controllers${i}` %>["<%= rpcModuleName %>"], typeof import('<%- t.segmentImports[segment.segmentName].fetcher %>').fetcher extends VovkFetcher<infer U> ? U : never>(
+  schema, '<%= segment.segmentName %>', '<%= rpcModuleName %>', import('<%- t.segmentImports[segment.segmentName].fetcher %>'),
+  { validateOnClient: <%- t.segmentImports[segment.segmentName].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 ? `apiRoot: '${apiRoot}'` : '' %> }
+);
+<% }) 
+}) %>
+export { schema };
+<% 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,76 @@
+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 '../utils/locateSegments.mjs';
+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,
+            openapiMixinName: cliBundleOptions?.openapiMixinName,
+            openapiFallback: cliBundleOptions?.openapiFallback,
+            composedFrom: [BuiltInTemplateName.tsBase],
+            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,
+            isBundle: true,
+            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/{diffSchema.d.mts → diffSegmentSchema.d.mts}

@@ -1,4 +1,4 @@
-import type { VovkControllerSchema, VovkSchema } from 'vovk';
+import type { VovkControllerSchema, VovkSegmentSchema } from 'vovk/internal';
 interface HandlersDiff {
     nameOfClass: string;
     added: string[];
@@ -14,7 +14,7 @@ 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 VovkSchema['controllers']>(oldItems: T, newItems: T): ControllersDiff;
+export declare function diffControllers<T extends VovkSegmentSchema['controllers']>(oldItems: T, newItems: T): ControllersDiff;
 /**
 example output:
 {
@@ -32,5 +32,5 @@ example output:
   }
 }
 */
-export default function diffSchema(oldJson: VovkSchema, newJson: VovkSchema): DiffResult;
+export declare function diffSegmentSchema(oldJson: VovkSegmentSchema, newJson: VovkSegmentSchema): DiffResult;
 export {};

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

@@ -57,7 +57,7 @@ example output:
   }
 }
 */
-export default function diffSchema(oldJson, newJson) {
+export function diffSegmentSchema(oldJson, newJson) {
     return {
         controllers: diffControllers(oldJson.controllers ?? {}, newJson.controllers ?? {}),
     };

package/dist/dev/ensureSchemaFiles.d.mts

@@ -2,5 +2,5 @@ import { ProjectInfo } from '../getProjectInfo/index.mjs';
 /**
  * Ensure that the schema files are created to avoid any import errors.
  */
-export default function ensureSchemaFiles(projectInfo: ProjectInfo | null, schemaOutAbsolutePath: string, segmentNames: string[]): Promise<void>;
+export declare 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,58 +1,27 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import debounce from 'lodash/debounce.js';
-import writeOneSchemaFile, { JSON_DIR_NAME, ROOT_SEGMENT_SCHEMA_NAME } from './writeOneSchemaFile.mjs';
-import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
+import { VovkSchemaIdEnum } from 'vovk/internal';
+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) {
+export async function ensureSchemaFiles(projectInfo, schemaOutAbsolutePath, segmentNames) {
     const now = Date.now();
     let hasChanged = false;
-    const schemaJsonOutAbsolutePath = path.join(schemaOutAbsolutePath, JSON_DIR_NAME);
-    const jsContent = `// auto-generated ${new Date().toISOString()}
-${segmentNames
-        .map((segmentName) => {
-        return `module.exports['${segmentName}'] = require('./${JSON_DIR_NAME}/${segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json');`;
-    })
-        .join('\n')}`;
-    const dTsContent = `// auto-generated ${new Date().toISOString()}
-import type { VovkSchema } from 'vovk';
-declare const fullSchema: {
-${segmentNames.map((segmentName) => `  '${segmentName}': VovkSchema;`).join('\n')}
-};
-export default fullSchema;`;
-    const tsContent = `// auto-generated ${new Date().toISOString()}
-import type { VovkSchema } from 'vovk';
-${segmentNames.map((segmentName, i) => `import segment${i} from './${JSON_DIR_NAME}/${segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json';`).join('\n')}
-const fullSchema = {
-${segmentNames.map((segmentName, i) => `  '${segmentName}': segment${i} as VovkSchema,`).join('\n')}
-};
-export default fullSchema;`;
-    const jsAbsolutePath = path.join(schemaOutAbsolutePath, 'main.cjs');
-    const dTsAbsolutePath = path.join(schemaOutAbsolutePath, 'main.d.cts');
-    const tsAbsolutePath = path.join(schemaOutAbsolutePath, 'index.ts');
-    const existingJs = await fs.readFile(jsAbsolutePath, 'utf-8').catch(() => null);
-    const existingDTs = await fs.readFile(dTsAbsolutePath, 'utf-8').catch(() => null);
-    const existingTs = await fs.readFile(tsAbsolutePath, 'utf-8').catch(() => null);
     await fs.mkdir(schemaOutAbsolutePath, { recursive: true });
-    // ignore 1st lines at the files
-    if (existingJs?.split('\n').slice(1).join('\n') !== jsContent.split('\n').slice(1).join('\n')) {
-        await fs.writeFile(jsAbsolutePath, jsContent);
-    }
-    if (existingDTs?.split('\n').slice(1).join('\n') !== dTsContent.split('\n').slice(1).join('\n')) {
-        await fs.writeFile(dTsAbsolutePath, dTsContent);
-    }
-    if (existingTs?.split('\n').slice(1).join('\n') !== tsContent.split('\n').slice(1).join('\n')) {
-        await fs.writeFile(tsAbsolutePath, tsContent);
-    }
+    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({
-            schemaJsonOutAbsolutePath,
-            schema: {
+        const { isCreated } = await writeOneSegmentSchemaFile({
+            schemaOutAbsolutePath,
+            segmentSchema: {
+                $schema: VovkSchemaIdEnum.SEGMENT,
                 emitSchema: false,
                 segmentName,
+                segmentType: 'segment',
                 controllers: {},
             },
             skipIfExists: true,
@@ -63,7 +32,7 @@ export default fullSchema;`;
         }
     }));
     // 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);
@@ -82,7 +51,8 @@ export default fullSchema;`;
                 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;
@@ -90,8 +60,7 @@ export default fullSchema;`;
             }
         }));
     }
-    // Start the recursive deletion from the root directory
-    await deleteUnnecessaryJsonFiles(schemaJsonOutAbsolutePath);
+    await deleteUnnecessaryJsonFiles(schemaOutAbsolutePath);
     if (hasChanged)
         projectInfo?.log.info(`Created empty schema files in ${Date.now() - now}ms`);
 }

package/dist/dev/index.d.mts

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