vovk 0.2.3-beta.12 → 0.2.3-beta.121

package/Segment.d.ts

@@ -2,6 +2,7 @@ import type { NextRequest } from 'next/server';
 import { _HttpMethod as HttpMethod, type _RouteHandler as RouteHandler } from './types';
 export declare class _Segment {
     #private;
+    private static getHeadersFromOptions;
     _routes: Record<HttpMethod, Map<{
         name?: string;
         _prefix?: string;

package/Segment.js

@@ -1,10 +1,23 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._Segment = void 0;
 const types_1 = require("./types");
 const HttpException_1 = require("./HttpException");
 const StreamResponse_1 = require("./StreamResponse");
 class _Segment {
+    static getHeadersFromOptions(options) {
+        const corsHeaders = {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS, HEAD',
+            'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+        };
+        const headers = {
+            ...(options?.cors ? corsHeaders : {}),
+            ...(options?.headers ?? {}),
+        };
+        return headers;
+    }
     _routes = {
         GET: new Map(),
         POST: new Map(),
@@ -14,18 +27,21 @@ class _Segment {
         HEAD: new Map(),
         OPTIONS: new Map(),
     };
-    GET = (req, data) => this.#callMethod(types_1._HttpMethod.GET, req, data.params);
+    GET = (req, data) => {
+        return this.#callMethod(types_1._HttpMethod.GET, req, data.params);
+    };
     POST = (req, data) => this.#callMethod(types_1._HttpMethod.POST, req, data.params);
     PUT = (req, data) => this.#callMethod(types_1._HttpMethod.PUT, req, data.params);
     PATCH = (req, data) => this.#callMethod(types_1._HttpMethod.PATCH, req, data.params);
     DELETE = (req, data) => this.#callMethod(types_1._HttpMethod.DELETE, req, data.params);
     HEAD = (req, data) => this.#callMethod(types_1._HttpMethod.HEAD, req, data.params);
     OPTIONS = (req, data) => this.#callMethod(types_1._HttpMethod.OPTIONS, req, data.params);
-    #respond = (status, body) => {
+    #respond = (status, body, options) => {
         return new Response(JSON.stringify(body), {
             status,
             headers: {
                 'Content-Type': 'application/json',
+                ..._a.getHeadersFromOptions(options),
             },
         });
     };
@@ -39,6 +55,9 @@ class _Segment {
     #callMethod = async (httpMethod, req, params) => {
         const controllers = this._routes[httpMethod];
         const methodParams = {};
+        if (params[Object.keys(params)[0]]?.[0] === '__ping') {
+            return this.#respond(200, { message: 'pong' });
+        }
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const handlers = Object.fromEntries([...controllers.entries()]
             .map(([controller, staticMethods]) => {
@@ -113,7 +132,12 @@ class _Segment {
                     (Reflect.has(result, Symbol.asyncIterator) &&
                         typeof result[Symbol.asyncIterator] === 'function'));
             if (isIterator && !(result instanceof Array)) {
-                const streamResponse = new StreamResponse_1._StreamResponse();
+                const streamResponse = new StreamResponse_1._StreamResponse({
+                    headers: {
+                        ...StreamResponse_1._StreamResponse.defaultHeaders,
+                        ..._a.getHeadersFromOptions(staticMethod._options),
+                    },
+                });
                 void (async () => {
                     try {
                         for await (const chunk of result) {
@@ -130,7 +154,7 @@ class _Segment {
             if (result instanceof Response) {
                 return result;
             }
-            return this.#respond(200, result ?? null);
+            return this.#respond(200, result ?? null, staticMethod._options);
         }
         catch (e) {
             const err = e;
@@ -150,3 +174,4 @@ class _Segment {
     };
 }
 exports._Segment = _Segment;
+_a = _Segment;

package/StreamResponse.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._StreamResponse = void 0;
 class _StreamResponse extends Response {
-    static JSON_DIVIDER = '__##DIV123##__'; // protects collisions with JSON data
+    static JSON_DIVIDER = '__##DIV123##__'; // protects collisions of JSON data
     static defaultHeaders = {
         'Content-Type': 'text/event-stream',
         Connection: 'keep-alive',
@@ -32,7 +32,6 @@ class _StreamResponse extends Response {
     }
     async throw(e) {
         const { writer } = this;
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         await this.send({ isError: true, reason: e instanceof Error ? e.message : e });
         await new Promise((resolve) => setTimeout(resolve, 0));
         return writer.abort(e);

package/cli/.eslintrc.js

@@ -7,6 +7,14 @@ module.exports = {
         '@typescript-eslint/no-unsafe-call': 'off',
         '@typescript-eslint/no-unsafe-member-access': 'off',
         '@typescript-eslint/no-unsafe-return': 'off',
-        'no-console': ['error', { allow: ['info', 'error'] }]
-    }
+        'no-console': ['error', { allow: ['info', 'error', 'warn'] }]
+    },
+    parserOptions: {
+        ecmaVersion: 2022,
+        sourceType: 'module',
+        project: '../tsconfig.cli.json',
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        tsconfigRootDir: __dirname,
+        createDefaultProgram: true,
+      },
 }

package/cli/generateClient.mjs

@@ -0,0 +1,122 @@
+// @ts-check
+import fs from 'fs/promises';
+import path from 'path';
+import getReturnPath from './lib/getReturnPath.mjs';
+
+/** @type {(moduleName: string) => Promise<boolean>} */
+async function fileExists(filePath) {
+  try {
+    await fs.stat(filePath);
+    return true; // The file exists
+  } catch (e) {
+    return false; // The file does not exist
+  }
+}
+
+/**
+ * Generates client code with string concatenation so it should be much faster than using AST
+ * TODO: Check fetcher for existence
+ * @type {(rcPath: import('../src').VovkEnv) => Promise<{ written: boolean; path: string }>}
+ */
+export default async function generateClient({ ...env }) {
+  const outDir = env.VOVK_CLIENT_OUT;
+  const returnDir = getReturnPath(outDir, process.cwd());
+  const jsonPath = path.join(returnDir, '.vovk.json');
+  const localJsonPath = path.join(process.cwd(), '.vovk.json');
+  const fetcherPath = env.VOVK_FETCHER.startsWith('.') ? path.join(returnDir, env.VOVK_FETCHER) : env.VOVK_FETCHER;
+
+  if (!env.VOVK_VALIDATE_ON_CLIENT) {
+    env.VOVK_VALIDATE_ON_CLIENT = (await fileExists('vovk-zod/zodValidateOnClient'))
+      ? 'vovk-zod/zodValidateOnClient'
+      : '';
+  }
+  const validatePath = env.VOVK_VALIDATE_ON_CLIENT.startsWith('.')
+    ? path.join(returnDir, env.VOVK_VALIDATE_ON_CLIENT)
+    : env.VOVK_VALIDATE_ON_CLIENT;
+  const localValidatePath = env.VOVK_VALIDATE_ON_CLIENT.startsWith('.') ? path.join('..', validatePath) : validatePath;
+
+  if (env.VOVK_VALIDATE_ON_CLIENT && !(await fileExists(localValidatePath))) {
+    throw new Error(
+      `Unble to generate Vovk Client: cannot find "validateOnClient" module '${env.VOVK_VALIDATE_ON_CLIENT}'. Check your vovk.config.js file`
+    );
+  }
+
+  if (!(await fileExists(localJsonPath))) {
+    throw new Error(
+      `Unble to generate Vovk Client: cannot find ".vovk.json" file '${localJsonPath}' (original value '${jsonPath}').`
+    );
+  }
+
+  const controllersPath = path.join(returnDir, env.VOVK_ROUTE).replace(/\.ts$/, '');
+  let dts = `// auto-generated
+/* eslint-disable */
+import type { Controllers, Workers } from "${controllersPath}";
+import type { clientizeController } from 'vovk/client';
+import type { promisifyWorker } from 'vovk/worker';
+import type { VovkClientFetcher } from 'vovk/client';
+import type fetcher from '${fetcherPath}';
+
+type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
+`;
+  let js = `// auto-generated
+/* eslint-disable */
+const { clientizeController } = require('vovk/client');
+const { promisifyWorker } = require('vovk/worker');
+const metadata = require('${jsonPath}');
+const { default: fetcher } = require('${fetcherPath}');
+const prefix = '${env.VOVK_PREFIX ?? '/api'}';
+const { default: validateOnClient = null } = ${validatePath ? `require('${validatePath}')` : '{}'};
+
+`;
+  let ts = `// auto-generated
+/* eslint-disable */
+import type { Controllers, Workers } from "${controllersPath}";
+import { clientizeController } from 'vovk/client';
+import { promisifyWorker } from 'vovk/worker';
+import type { VovkClientFetcher } from 'vovk/client';
+import fetcher from '${fetcherPath}';
+import metadata from '${jsonPath}';
+${validatePath ? `import validateOnClient from '${validatePath}';\n` : '\nconst validateOnClient = undefined;'}
+const prefix = '${env.VOVK_PREFIX ?? '/api'}';
+type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
+`;
+  const metadataJson = await fs.readFile(localJsonPath, 'utf-8').catch(() => null);
+
+  if (!metadataJson) console.warn(` 🐺 No .vovk.json file found in ${localJsonPath}`);
+
+  const metadata = JSON.parse(metadataJson || '{}');
+
+  for (const key of Object.keys(metadata)) {
+    if (key !== 'workers') {
+      dts += `export const ${key}: ReturnType<typeof clientizeController<Controllers["${key}"], Options>>;\n`;
+      js += `exports.${key} = clientizeController(metadata.${key}, { fetcher, validateOnClient, defaultOptions: { prefix } });\n`;
+      ts += `export const ${key} = clientizeController<Controllers["${key}"], Options>(metadata.${key}, { fetcher, validateOnClient, defaultOptions: { prefix } });\n`;
+    }
+  }
+
+  for (const key of Object.keys(metadata.workers ?? {})) {
+    dts += `export const ${key}: ReturnType<typeof promisifyWorker<Workers["${key}"]>>;\n`;
+    js += `exports.${key} = promisifyWorker(null, metadata.workers.${key});\n`;
+    ts += `export const ${key} = promisifyWorker<Workers["${key}"]>(null, metadata.workers.${key});\n`;
+  }
+
+  /* js += `
+    if(typeof window !== 'undefined') fetch(prefix + '/__ping', { method: 'POST' });
+  `; */
+
+  const localJsPath = path.join(outDir, 'client.js');
+  const localDtsPath = path.join(outDir, 'client.d.ts');
+  const localTsPath = path.join(outDir, 'index.ts');
+  const existingJs = await fs.readFile(localJsPath, 'utf-8').catch(() => '');
+  const existingDts = await fs.readFile(localDtsPath, 'utf-8').catch(() => '');
+  const existingTs = await fs.readFile(localTsPath, 'utf-8').catch(() => '');
+
+  if (existingJs === js && existingDts === dts && existingTs === ts) return { written: false, path: outDir };
+
+  await fs.mkdir(outDir, { recursive: true });
+  await fs.writeFile(localJsPath, js);
+  await fs.writeFile(localDtsPath, dts);
+  await fs.writeFile(localTsPath, ts);
+
+  return { written: true, path: outDir };
+}

package/cli/getVars.mjs

@@ -0,0 +1,45 @@
+// @ts-check
+
+import path from 'path';
+
+/** @type {import('../src').VovkEnv} */
+let vars;
+/** @type {(rcPath: string, options?: { VOVK_CLIENT_OUT?: string; PORT?: string; }) => Promise<import('../src').VovkEnv>} */
+export default async function getVars(configPath, options = {}) {
+  if (vars) return vars;
+  /** @type {Required<import('../src').VovkConfig>} */
+  const vovkConfig = {
+    out: './node_modules/.vovk',
+    route: './src/app/api/[[...vovk]]/route.ts',
+    fetcher: 'vovk/client/defaultFetcher',
+    prefix: '/api',
+    validateOnClient: '',
+  };
+
+  try {
+    // make PORT available to the config file
+    process.env.PORT = options.PORT || process.env.PORT || '3000';
+    Object.assign(vovkConfig, await import(configPath));
+  } catch {
+    // noop
+  }
+
+  vars = {
+    PORT: options.PORT || process.env.PORT || '3000',
+    VOVK_CLIENT_OUT:
+      process.env.VOVK_CLIENT_OUT ||
+      (options.VOVK_CLIENT_OUT?.startsWith('/')
+        ? options.VOVK_CLIENT_OUT
+        : options.VOVK_CLIENT_OUT
+          ? path.join(process.cwd(), options.VOVK_CLIENT_OUT)
+          : null) ||
+      vovkConfig.out,
+    VOVK_PORT: process.env.VOVK_PORT || '3690',
+    VOVK_ROUTE: process.env.VOVK_ROUTE || vovkConfig.route,
+    VOVK_FETCHER: process.env.VOVK_FETCHER || vovkConfig.fetcher,
+    VOVK_PREFIX: process.env.VOVK_PREFIX || vovkConfig.prefix,
+    VOVK_VALIDATE_ON_CLIENT: process.env.VOVK_VALIDATE_ON_CLIENT || vovkConfig.validateOnClient,
+  };
+
+  return vars;
+}

package/cli/index.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+// @ts-check
+import path from 'path';
+import generateClient from './generateClient.mjs';
+import parallel from './lib/parallel.mjs';
+import getAvailablePort from './lib/getAvailablePort.mjs';
+import getVars from './getVars.mjs';
+import parseCommandLineArgs from './lib/parseCommandLineArgs.mjs';
+import { fileURLToPath } from 'url';
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore Ignore meta-property error
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const { command, flags, restArgs } = parseCommandLineArgs();
+const {
+  config = path.join(process.cwd(), 'vovk.config.js'), // Path to vovk.config.js
+  // TODO not documented
+  project = process.cwd(), // Path to Next.js project
+  clientOut = path.join(process.cwd(), './node_modules/.vovk'), // Path to output directory
+} = flags;
+
+if (command === 'dev') {
+  void (async () => {
+    let PORT =
+      process.env.PORT ||
+      (await getAvailablePort(3000, 30).catch(() => {
+        throw new Error(' 🐺 Failed to find available Next port');
+      }));
+
+    const env = await getVars(config, { VOVK_CLIENT_OUT: clientOut, PORT });
+
+    let VOVK_PORT = parseInt(env.VOVK_PORT);
+
+    env.VOVK_PORT = await getAvailablePort(VOVK_PORT, 30).catch(() => {
+      throw new Error(' 🐺 Failed to find available Vovk port');
+    });
+
+    await parallel(
+      [
+        {
+          command: `node ${__dirname}/server.mjs`,
+          name: 'Vovk',
+        },
+        { command: `cd ${project} && npx next dev ${restArgs}`, name: 'Next' },
+      ],
+      env
+    ).catch((e) => console.error(e));
+    console.info(' 🐺 All processes have ended');
+  })();
+} else if (command === 'generate') {
+  void (async () => {
+    const env = await getVars(config, { VOVK_CLIENT_OUT: clientOut });
+
+    void generateClient(env).then(({ path }) => {
+      console.info(` 🐺 Client generated in ${path}`);
+    });
+  })();
+} else if (command === 'help') {
+  console.info(` 🐺 Vovk CLI
+  dev - Start development server
+  generate - Generate client
+  help - Show this help message`);
+} else {
+  console.error(' 🐺 ❌ Invalid command');
+  process.exit(1);
+}

package/cli/lib/getAvailablePort.mjs

@@ -0,0 +1,30 @@
+import net from 'net';
+
+function checkPort(port, callback) {
+  const server = net.createServer();
+
+  server.listen(port, () => {
+    server.close(() => {
+      callback(true); // Port is available
+    });
+  });
+
+  server.on('error', () => {
+    callback(false);
+  });
+}
+
+/** @type {(startPort: number, maxAttempts: number, attempt?: number) => Promise<string>} */
+export default function getAvailablePort(startPort, maxAttempts, attempt = 1) {
+  return new Promise((resolve, reject) => {
+    checkPort(startPort, (isAvailable) => {
+      if (isAvailable) {
+        resolve(startPort.toString()); // Found an available port
+      } else if (attempt < maxAttempts) {
+        getAvailablePort(startPort + 1, maxAttempts, attempt + 1).then(resolve, reject);
+      } else {
+        reject(null);
+      }
+    });
+  });
+}

package/cli/lib/getReturnPath.mjs

@@ -0,0 +1,26 @@
+// @ts-check
+/** @type {(fromPath: string, toPath: string) => string} */
+export default function getReturnPath(fromPath, toPath) {
+  // Split the paths into components
+  const fromParts = fromPath.replace(/^\.?\/|\/$/g, '').split('/');
+  const toParts = toPath.replace(/^\.?\/|\/$/g, '').split('/');
+
+  // Find the common base path length
+  const length = Math.min(fromParts.length, toParts.length);
+  let commonBaseLength = 0;
+  for (let i = 0; i < length; i++) {
+    if (fromParts[i] !== toParts[i]) break;
+    commonBaseLength++;
+  }
+
+  // Calculate steps up to the common base
+  const stepsUp = '../'.repeat(fromParts.length - commonBaseLength);
+
+  // Calculate steps down to the target path
+  const stepsDown = toParts.slice(commonBaseLength).join('/');
+
+  // Combine steps up and steps down
+  const result = stepsUp + stepsDown;
+
+  return result;
+}

package/cli/lib/isEqual.mjs

@@ -0,0 +1,26 @@
+// @ts-check
+/** @type {(obj1: any, obj2: any) => boolean} */
+export default function isEqual(obj1, obj2) {
+  if (obj1 === obj2) {
+    return true;
+  }
+
+  if (typeof obj1 !== 'object' || typeof obj2 !== 'object' || obj1 == null || obj2 == null) {
+    return false;
+  }
+
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+
+  for (const key of keys1) {
+    if (!keys2.includes(key) || !isEqual(obj1[key], obj2[key])) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/cli/lib/parallel.mjs

@@ -0,0 +1,48 @@
+// @ts-check
+import { spawn } from 'child_process';
+
+/** @type {(commands: { command: string; name: string; }[], env: import('../../src').VovkEnv) => Promise<void>} */
+export default function parallel(commands, env) {
+  return new Promise((resolve, reject) => {
+    /** @type {{ name: string; process: import('child_process').ChildProcess; }[]} */
+    let processes = [];
+
+    commands.forEach((cmd) => {
+      const processObj = {
+        name: cmd.name,
+        process: runCommand(
+          cmd.command,
+          cmd.name,
+          /** @type {(code: number) => void} */
+          (code) => handleProcessExit(code, cmd.name)
+        ),
+      };
+      processes.push(processObj);
+    });
+
+    /** @type {(command: string, name: string, onExit: (code: number) => void) => import('child_process').ChildProcess} */
+    function runCommand(command, name, onExit) {
+      const proc = spawn(command, { shell: true, env: { ...env, ...process.env }, stdio: 'inherit' });
+
+      proc.on('exit', onExit);
+
+      return proc;
+    }
+
+    /** @type {(code: number, name: string) => void} */
+    function handleProcessExit(code, name) {
+      processes = processes.filter((p) => p.name !== name);
+
+      if (code !== 0) {
+        processes.forEach((p) => p.name !== name && p.process.kill('SIGINT'));
+        processes = [];
+        process.stdout.write('\n');
+        return reject(new Error(`Process ${name} exited with code ${code}`));
+      }
+
+      if (!processes.length) {
+        resolve();
+      }
+    }
+  });
+}

package/cli/lib/parseCommandLineArgs.mjs

@@ -0,0 +1,39 @@
+// @ts-check
+
+/** @type {(str: string) => string} */
+function toCamelCase(str) {
+  return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+}
+
+/** @typedef {{ config?: string; project?: string; clientOut?: string }} Flags */
+/** @typedef {'dev' | 'build' | 'generate' | 'help'} Command */
+export default function parseCommandLineArgs() {
+  const args = process.argv.slice(2); // Slice off node and script path
+  let command = /** @type {Command} */ null;
+  /** @type {Flags} */
+  const flags = {};
+  /** @type {string[]} */
+  const unparsedArgs = [];
+
+  let isUnparsed = false;
+  for (const arg of args) {
+    if (arg === '--') {
+      isUnparsed = true;
+      continue;
+    }
+
+    if (isUnparsed) {
+      unparsedArgs.push(arg);
+    } else if (arg.startsWith('--')) {
+      const [key, value = true] = arg.slice(2).split('=');
+      const camelKey = /** @type {keyof Flags} */ (toCamelCase(key));
+      flags[camelKey] = /** @type {string} */ (value);
+    } else if (!command) {
+      command = /** @type {Command} */ (arg);
+    }
+  }
+
+  const restArgs = unparsedArgs.join(' ');
+
+  return { command, flags, restArgs };
+}

package/cli/postinstall.mjs

@@ -0,0 +1,29 @@
+// @ts-check
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore Ignore meta-property error
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/** @type {(path: string) => Promise<boolean>} */
+const fileExists = async (path) => !!(await fs.stat(path).catch(() => false));
+
+async function postinstall() {
+  const vovk = path.join(__dirname, '../../.vovk');
+  const js = path.join(vovk, 'client.js');
+  const ts = path.join(vovk, 'client.d.ts');
+  const index = path.join(vovk, 'index.ts');
+
+  if ((await fileExists(js)) || (await fileExists(ts)) || (await fileExists(index))) {
+    return;
+  }
+
+  await fs.mkdir(vovk, { recursive: true });
+  await fs.writeFile(js, '/* postinstall */');
+  await fs.writeFile(ts, '/* postinstall */');
+  await fs.writeFile(index, '/* postinstall */');
+}
+
+void postinstall();