vovk-cli 0.0.1-beta.7 → 0.0.1-beta.71

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,37 @@
-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 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)
+
+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/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
+
+```sh
+npx vovk-cli --help
+```

package/client-templates/jsBase/index.d.mts.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.cjs';
+<% if (t.hasMixins) { %>
+export { Mixins };
+<% } %>

package/client-templates/jsBase/index.mjs.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.js.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/diffSegmentSchema.d.mts

@@ -0,0 +1,36 @@
+import type { VovkControllerSchema, VovkSegmentSchema } from 'vovk/internal';
+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 declare function diffSegmentSchema(oldJson: VovkSegmentSchema, newJson: VovkSegmentSchema): DiffResult;
+export {};

package/dist/{server/diffMetadata.mjs → dev/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 = [];
@@ -27,7 +27,7 @@ export function diffWorkersOrControllers(oldItems, newItems) {
             added.push(item);
         }
         else {
-            const handlers = diffHandlers(oldItems[item]._handlers, newItem._handlers, item);
+            const handlers = diffHandlers(oldItems[item].handlers, newItem.handlers, item);
             if (handlers.added.length || handlers.removed.length || handlers.changed.length) {
                 handlersDiff.push(handlers);
             }
@@ -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 diffMetadata(oldJson, newJson) {
-    const workersDiff = diffWorkersOrControllers(oldJson.workers ?? {}, newJson.workers ?? {});
-    const controllersDiff = diffWorkersOrControllers(oldJson.controllers ?? {}, newJson.controllers ?? {});
+export function diffSegmentSchema(oldJson, newJson) {
     return {
-        workers: workersDiff,
-        controllers: controllersDiff,
+        controllers: diffControllers(oldJson.controllers ?? {}, newJson.controllers ?? {}),
     };
 }

package/dist/dev/ensureSchemaFiles.d.mts

@@ -0,0 +1,6 @@
+import { ProjectInfo } from '../getProjectInfo/index.mjs';
+/**
+ * Ensure that the schema files are created to avoid any import errors.
+ */
+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

@@ -0,0 +1,67 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import debounce from 'lodash/debounce.js';
+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 async function ensureSchemaFiles(projectInfo, schemaOutAbsolutePath, segmentNames) {
+    const now = Date.now();
+    let hasChanged = false;
+    await fs.mkdir(schemaOutAbsolutePath, { recursive: true });
+    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 writeOneSegmentSchemaFile({
+            schemaOutAbsolutePath,
+            segmentSchema: {
+                $schema: VovkSchemaIdEnum.SEGMENT,
+                emitSchema: false,
+                segmentName,
+                segmentType: 'segment',
+                controllers: {},
+            },
+            skipIfExists: true,
+        });
+        if (isCreated) {
+            projectInfo?.log.debug(`Created empty schema file for ${formatLoggedSegmentName(segmentName)}`);
+            hasChanged = true;
+        }
+    }));
+    // Recursive function to delete unnecessary JSON files and folders
+    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);
+            if (entry.isDirectory()) {
+                // Recursively delete unnecessary files and folders within nested directories
+                await deleteUnnecessaryJsonFiles(absolutePath);
+                // Check if the directory is empty after deletion and remove it if so
+                const remainingEntries = await fs.readdir(absolutePath);
+                if (remainingEntries.length === 0) {
+                    await fs.rmdir(absolutePath);
+                    projectInfo?.log.debug(`Deleted unnecessary schema directory "${absolutePath}"`);
+                    hasChanged = true;
+                }
+            }
+            else if (entry.isFile() && entry.name.endsWith('.json')) {
+                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_FILE_NAME, '')) &&
+                    !allow.includes(entry.name)) {
+                    await fs.unlink(absolutePath);
+                    projectInfo?.log.debug(`Deleted unnecessary schema file for ${formatLoggedSegmentName(segmentName)}`);
+                    hasChanged = true;
+                }
+            }
+        }));
+    }
+    await deleteUnnecessaryJsonFiles(schemaOutAbsolutePath);
+    if (hasChanged)
+        projectInfo?.log.info(`Created empty schema files in ${Date.now() - now}ms`);
+}
+export const debouncedEnsureSchemaFiles = debounce(ensureSchemaFiles, 1000);

package/dist/dev/index.d.mts

@@ -0,0 +1,8 @@
+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>;
+}