vovk-cli 0.0.1-beta.0

package/dist/locateSegments.js

@@ -0,0 +1,58 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = locateSegments;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const fileExists_1 = __importDefault(require("./utils/fileExists"));
+async function locateSegments(dir, rootDir = dir) {
+    let results = [];
+    // Read the contents of the directory
+    const list = await fs_1.promises.readdir(dir);
+    // Iterate through each item in the directory
+    for (const file of list) {
+        const filePath = path.join(dir, file);
+        const stat = await fs_1.promises.stat(filePath);
+        if (stat.isDirectory()) {
+            // Check if the directory name matches the pattern [[...something]]
+            if (file.startsWith('[[...') && file.endsWith(']]')) {
+                // Check if there's a route.ts file inside this directory
+                const routeFilePath = path.join(filePath, 'route.ts');
+                if (await (0, fileExists_1.default)(routeFilePath)) {
+                    // Calculate the basePath relative to the root directory
+                    const segmentName = path.relative(rootDir, dir);
+                    results.push({ routeFilePath, segmentName });
+                }
+            }
+            // Recursively search inside subdirectories
+            const subDirResults = await locateSegments(filePath, rootDir);
+            results = results.concat(subDirResults);
+        }
+    }
+    return results;
+}

package/dist/postinstall.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/postinstall.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+/**
+ * Checks if a file exists at the given path.
+ * @param {string} filePath - The path to the file.
+ * @returns {Promise<boolean>} - A promise that resolves to true if the file exists, false otherwise.
+ */
+const fileExists = async (filePath) => !!(await fs_1.promises.stat(filePath).catch(() => false));
+async function postinstall() {
+    const vovk = path_1.default.join(__dirname, '../../.vovk');
+    const js = path_1.default.join(vovk, 'client.js');
+    const ts = path_1.default.join(vovk, 'client.d.ts');
+    const index = path_1.default.join(vovk, 'index.ts');
+    if ((await fileExists(js)) || (await fileExists(ts)) || (await fileExists(index))) {
+        return;
+    }
+    await fs_1.promises.mkdir(vovk, { recursive: true });
+    await fs_1.promises.writeFile(js, '/* postinstall */');
+    await fs_1.promises.writeFile(ts, '/* postinstall */');
+    await fs_1.promises.writeFile(index, '/* postinstall */');
+}
+void postinstall();

package/dist/server/createMetadataServer.d.ts

@@ -0,0 +1,5 @@
+import http from 'http';
+import { VovkMetadata } from 'vovk';
+export default function createMetadataServer(then: (metadata: {
+    metadata: VovkMetadata;
+}) => void | Promise<void>, catchFn: (err: Error) => void | Promise<void>): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;

package/dist/server/createMetadataServer.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createMetadataServer;
+const http_1 = __importDefault(require("http"));
+function createMetadataServer(then, catchFn) {
+    return http_1.default.createServer((req, res) => {
+        if (req.method === 'POST' && req.url === '/__metadata') {
+            let body = '';
+            req.on('data', (chunk) => {
+                body += chunk.toString();
+            });
+            req.on('end', () => {
+                try {
+                    const result = JSON.parse(body);
+                    void then(result);
+                }
+                catch (e) {
+                    void catchFn(e);
+                }
+            });
+        }
+        else {
+            res.writeHead(404, { 'Content-Type': 'text/plain' });
+            res.end('Not Found');
+            void catchFn(new Error('Not Found'));
+        }
+    });
+}

package/dist/server/diffMetadata.d.ts

@@ -0,0 +1,43 @@
+import { VovkMetadata } from 'vovk';
+import { _VovkControllerMetadata, _VovkWorkerMetadata } from 'vovk/types';
+interface HandlersDiff {
+    nameOfClass: string;
+    added: string[];
+    removed: string[];
+    changed: string[];
+}
+interface WorkersOrControllersDiff {
+    added: string[];
+    removed: string[];
+    handlers: HandlersDiff[];
+}
+export interface DiffResult {
+    workers: WorkersOrControllersDiff;
+    controllers: WorkersOrControllersDiff;
+}
+export declare function diffHandlers<T extends _VovkWorkerMetadata['_handlers'] | _VovkControllerMetadata['_handlers']>(oldHandlers: T, newHandlers: T, nameOfClass: string): HandlersDiff;
+export declare function diffWorkersOrControllers<T extends VovkMetadata['controllers'] | VovkMetadata['workers']>(oldItems: T, newItems: T): WorkersOrControllersDiff;
+/**
+example output:
+{
+  workers: {
+    added: ["WorkerC"],
+    removed: ["WorkerA"],
+    handlers: []
+  },
+  controllers: {
+    added: ["ControllerC"],
+    removed: ["ControllerB"],
+    handlers: [
+      {
+        nameOfClass: "ControllerA",
+        added: ["handlerF"],
+        removed: [],
+        changed: ["handlerD"]
+      }
+    ]
+  }
+}
+*/
+export default function diffMetadata(oldJson: VovkMetadata, newJson: VovkMetadata): DiffResult;
+export {};

package/dist/server/diffMetadata.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffHandlers = diffHandlers;
+exports.diffWorkersOrControllers = diffWorkersOrControllers;
+exports.default = diffMetadata;
+const lodash_1 = require("lodash");
+function diffHandlers(oldHandlers, newHandlers, nameOfClass) {
+    const added = [];
+    const removed = [];
+    const changed = []; // Array to store changed handlers
+    for (const [handler, newHandler] of Object.entries(newHandlers)) {
+        if (!(handler in oldHandlers)) {
+            added.push(handler);
+        }
+        else if (!(0, lodash_1.isEqual)(newHandler, oldHandlers[handler])) {
+            changed.push(handler); // Add to changed if handlers are not shallow equal
+        }
+    }
+    for (const [handler] of Object.entries(oldHandlers)) {
+        if (!(handler in newHandlers)) {
+            removed.push(handler);
+        }
+    }
+    return { nameOfClass, added, removed, changed };
+}
+function diffWorkersOrControllers(oldItems, newItems) {
+    const added = [];
+    const removed = [];
+    const handlersDiff = [];
+    for (const [item, newItem] of Object.entries(newItems)) {
+        if (!(item in oldItems)) {
+            added.push(item);
+        }
+        else {
+            const handlers = diffHandlers(oldItems[item]._handlers, newItem._handlers, item);
+            if (handlers.added.length || handlers.removed.length || handlers.changed.length) {
+                handlersDiff.push(handlers);
+            }
+        }
+    }
+    for (const [item] of Object.entries(oldItems)) {
+        if (!(item in newItems)) {
+            removed.push(item);
+        }
+    }
+    return { added, removed, handlers: handlersDiff };
+}
+/**
+example output:
+{
+  workers: {
+    added: ["WorkerC"],
+    removed: ["WorkerA"],
+    handlers: []
+  },
+  controllers: {
+    added: ["ControllerC"],
+    removed: ["ControllerB"],
+    handlers: [
+      {
+        nameOfClass: "ControllerA",
+        added: ["handlerF"],
+        removed: [],
+        changed: ["handlerD"]
+      }
+    ]
+  }
+}
+*/
+function diffMetadata(oldJson, newJson) {
+    const workersDiff = diffWorkersOrControllers(oldJson.workers ?? {}, newJson.workers ?? {});
+    const controllersDiff = diffWorkersOrControllers(oldJson.controllers ?? {}, newJson.controllers ?? {});
+    return {
+        workers: workersDiff,
+        controllers: controllersDiff,
+    };
+}

package/dist/server/ensureMetadataFiles.d.ts

@@ -0,0 +1,3 @@
+import { ProjectInfo } from '../getProjectInfo';
+export default function ensureMetadataFiles(metadataOutFullPath: string, segmentNames: string[], projectInfo: ProjectInfo | null): Promise<void>;
+export declare const debouncedEnsureMetadataFiles: import("lodash").DebouncedFunc<typeof ensureMetadataFiles>;

package/dist/server/ensureMetadataFiles.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debouncedEnsureMetadataFiles = void 0;
+exports.default = ensureMetadataFiles;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const debounce_1 = __importDefault(require("lodash/debounce"));
+const writeOneMetadataFile_1 = __importStar(require("./writeOneMetadataFile"));
+async function ensureMetadataFiles(metadataOutFullPath, segmentNames, projectInfo) {
+    const now = Date.now();
+    let hasChanged = false;
+    // Create index.js file
+    const indexContent = segmentNames
+        .map((segmentName) => {
+        return `module.exports['${segmentName}'] = require('./${segmentName || writeOneMetadataFile_1.ROOT_SEGMENT_SCHEMA_NAME}.json');`;
+    })
+        .join('\n');
+    const dTsContent = `import type { VovkMetadata } from 'vovk';
+declare const segmentMetadata: Record<string, VovkMetadata>;
+export default segmentMetadata;`;
+    await promises_1.default.mkdir(metadataOutFullPath, { recursive: true });
+    await promises_1.default.writeFile(path_1.default.join(metadataOutFullPath, 'index.js'), indexContent);
+    await promises_1.default.writeFile(path_1.default.join(metadataOutFullPath, 'index.d.ts'), dTsContent);
+    // Create JSON files (if not exist) with name [segmentName].json (where segmentName can include /, which means the folder structure can be nested) : {} (empty object)
+    await Promise.all(segmentNames.map(async (segmentName) => {
+        const { isCreated } = await (0, writeOneMetadataFile_1.default)({
+            metadataOutFullPath,
+            metadata: {
+                emitMetadata: false,
+                segmentName,
+                controllers: {},
+                workers: {},
+            },
+            skipIfExists: true,
+        });
+        if (isCreated) {
+            projectInfo?.log.debug(`Created empty metadata file for segment "${segmentName}"`);
+            hasChanged = true;
+        }
+    }));
+    // Recursive function to delete unnecessary JSON files and folders
+    async function deleteUnnecessaryJsonFiles(dirPath) {
+        const entries = await promises_1.default.readdir(dirPath, { withFileTypes: true });
+        await Promise.all(entries.map(async (entry) => {
+            const fullPath = path_1.default.join(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                // Recursively delete unnecessary files and folders within nested directories
+                await deleteUnnecessaryJsonFiles(fullPath);
+                // Check if the directory is empty after deletion and remove it if so
+                const remainingEntries = await promises_1.default.readdir(fullPath);
+                if (remainingEntries.length === 0) {
+                    await promises_1.default.rmdir(fullPath);
+                    projectInfo?.log.debug(`Deleted unnecessary metadata directory "${fullPath}"`);
+                    hasChanged = true;
+                }
+            }
+            else if (entry.isFile() && entry.name.endsWith('.json')) {
+                const relativePath = path_1.default.relative(metadataOutFullPath, fullPath);
+                const segmentName = relativePath.replace(/\\/g, '/').slice(0, -5); // Remove '.json' extension
+                if (!segmentNames.includes(segmentName) &&
+                    !segmentNames.includes(segmentName.replace(writeOneMetadataFile_1.ROOT_SEGMENT_SCHEMA_NAME, ''))) {
+                    await promises_1.default.unlink(fullPath);
+                    projectInfo?.log.debug(`Deleted unnecessary metadata file for segment "${segmentName}"`);
+                    hasChanged = true;
+                }
+            }
+        }));
+    }
+    // Start the recursive deletion from the root directory
+    await deleteUnnecessaryJsonFiles(metadataOutFullPath);
+    if (hasChanged)
+        projectInfo?.log.info(`Metadata files updated in ${Date.now() - now}ms`);
+}
+exports.debouncedEnsureMetadataFiles = (0, debounce_1.default)(ensureMetadataFiles, 1000);

package/dist/server/generateClient.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectInfo } from '../getProjectInfo';
+import type { Segment } from '../locateSegments';
+import { VovkMetadata } from 'vovk';
+export default function generateClient(projectInfo: ProjectInfo, segments: Segment[], segmentsMetadata: Record<string, VovkMetadata>): Promise<{
+    written: boolean;
+    path: string;
+}>;

package/dist/server/generateClient.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = generateClient;
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+async function generateClient(projectInfo, segments, segmentsMetadata) {
+    const now = Date.now();
+    const outDir = projectInfo.clientOutFullPath;
+    const validatePath = projectInfo.config.validateOnClient?.startsWith('.')
+        ? path_1.default.join(projectInfo.cwd, projectInfo.config.validateOnClient)
+        : projectInfo.config.validateOnClient;
+    let dts = `// auto-generated
+/* eslint-disable */
+import type { clientizeController } from 'vovk/client';
+import type { promisifyWorker } from 'vovk/worker';
+import type { VovkClientFetcher } from 'vovk/client';
+import type fetcher from '${projectInfo.fetcherClientImportPath}';
+
+`;
+    let js = `// auto-generated
+/* eslint-disable */
+const { clientizeController } = require('vovk/client');
+const { promisifyWorker } = require('vovk/worker');
+const { default: fetcher } = require('${projectInfo.fetcherClientImportPath}');
+const metadata = require('${projectInfo.metadataOutImportPath}');
+`;
+    let ts = `// auto-generated
+/* eslint-disable */
+import { clientizeController } from 'vovk/client';
+import { promisifyWorker } from 'vovk/worker';
+import type { VovkClientFetcher } from 'vovk/client';
+import fetcher from '${projectInfo.fetcherClientImportPath}';
+import metadata from '${projectInfo.metadataOutImportPath}';
+
+`;
+    for (let i = 0; i < segments.length; i++) {
+        const { routeFilePath, segmentName } = segments[i];
+        const metadata = segmentsMetadata[segmentName];
+        if (!metadata) {
+            throw new Error(`Unable to generate client. No metadata found for segment ${segmentName}`);
+        }
+        if (!metadata.emitMetadata)
+            continue;
+        const importRouteFilePath = path_1.default.relative(projectInfo.config.clientOutDir, routeFilePath);
+        dts += `import type { Controllers as Controllers${i}, Workers as Workers${i} } from "${importRouteFilePath}";\n`;
+        ts += `import type { Controllers as Controllers${i}, Workers as Workers${i} } from "${importRouteFilePath}";\n`;
+    }
+    dts += `
+type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
+  `;
+    ts += `
+${validatePath ? `import validateOnClient from '${validatePath}';\n` : '\nconst validateOnClient = undefined;'}
+type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
+const prefix = '${projectInfo.apiPrefix}';
+  `;
+    js += `
+const { default: validateOnClient = null } = ${validatePath ? `require('${validatePath}')` : '{}'};
+const prefix = '${projectInfo.apiPrefix}';
+`;
+    for (let i = 0; i < segments.length; i++) {
+        const { segmentName } = segments[i];
+        const metadata = segmentsMetadata[segmentName];
+        if (!metadata) {
+            throw new Error(`Unable to generate client. No metadata found for segment ${segmentName}`);
+        }
+        if (!metadata.emitMetadata)
+            continue;
+        for (const key of Object.keys(metadata.controllers)) {
+            dts += `export const ${key}: ReturnType<typeof clientizeController<Controllers${i}["${key}"], Options>>;\n`;
+            js += `exports.${key} = clientizeController(metadata['${segmentName}'].controllers.${key}, '${segmentName}', { fetcher, validateOnClient, defaultOptions: { prefix } });\n`;
+            ts += `export const ${key} = clientizeController<Controllers${i}["${key}"], Options>(metadata['${segmentName}'].controllers.${key}, '${segmentName}', { fetcher, validateOnClient, defaultOptions: { prefix } });\n`;
+        }
+        for (const key of Object.keys(metadata.workers)) {
+            dts += `export const ${key}: ReturnType<typeof promisifyWorker<Workers${i}["${key}"]>>;\n`;
+            js += `exports.${key} = promisifyWorker(null, metadata['${segmentName}'].workers.${key});\n`;
+            ts += `export const ${key} = promisifyWorker<Workers${i}["${key}"]>(null, metadata['${segmentName}'].workers.${key});\n`;
+        }
+    }
+    const localJsPath = path_1.default.join(outDir, 'client.js');
+    const localDtsPath = path_1.default.join(outDir, 'client.d.ts');
+    const localTsPath = path_1.default.join(outDir, 'index.ts');
+    const existingJs = await promises_1.default.readFile(localJsPath, 'utf-8').catch(() => '');
+    const existingDts = await promises_1.default.readFile(localDtsPath, 'utf-8').catch(() => '');
+    const existingTs = await promises_1.default.readFile(localTsPath, 'utf-8').catch(() => '');
+    if (existingJs === js && existingDts === dts && existingTs === ts) {
+        projectInfo.log.info(`Client is up to date and doesn't need to be regenerated (${Date.now() - now}ms).`);
+        return { written: false, path: outDir };
+    }
+    await promises_1.default.mkdir(outDir, { recursive: true });
+    await promises_1.default.writeFile(localJsPath, js);
+    await promises_1.default.writeFile(localDtsPath, dts);
+    await promises_1.default.writeFile(localTsPath, ts);
+    projectInfo.log.info(`Client generated in ${Date.now() - now}ms`);
+    return { written: true, path: outDir };
+}

package/dist/server/index.d.ts

@@ -0,0 +1,6 @@
+export declare class VovkCLIServer {
+    #private;
+    startServer({ clientOutDir }?: {
+        clientOutDir?: string;
+    }): Promise<void>;
+}