vovk 0.2.3-beta.3 → 0.2.3-beta.4

package/cli/.eslintrc.js

@@ -0,0 +1,12 @@
+module.exports = {
+    extends: '../.eslintrc.js',
+    rules: {
+        '@typescript-eslint/no-unsafe-argument': 'off',
+        '@typescript-eslint/no-unsafe-assignment': 'off',
+        '@typescript-eslint/no-var-requires': 'off',
+        '@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'] }]
+    }
+}

package/cli/generateClient.js

@@ -0,0 +1,52 @@
+const fs = require('fs/promises');
+const path = require('path');
+const getVovkrc = require('./getVovkrc');
+/**
+ * Generates client code with string concatenation so it should be super fast
+ * @type {(rcPath: string) => Promise<void>}
+ */
+async function generateClient(rcPath) {
+  const vovkrc = getVovkrc(rcPath);
+
+  const fetcherPath = vovkrc.fetcher.startsWith('.') ? path.join(process.cwd(), vovkrc.fetcher) : vovkrc.fetcher;
+  const streamFetcherPath = vovkrc.streamFetcher.startsWith('.')
+    ? path.join(process.cwd(), vovkrc.streamFetcher)
+    : vovkrc.streamFetcher;
+
+  const controllersPath = path.join('..', vovkrc.route).replace(/\.ts$/, '');
+  let ts = `import type { Controllers } from "${controllersPath}";
+import type { clientizeController } from 'vovk/client';
+import type { promisifyWorker } from 'vovk/worker';
+import type { VovkFetcherOptions } from 'vovk/client';
+import type fetcher from '${fetcherPath}';
+
+type Options = typeof fetcher extends VovkFetcherOptions<infer U> ? U : never;
+`;
+  let js = `const { clientizeController } = require('vovk/client');
+const { promisifyWorker } = require('vovk/worker');
+const metadata = require('./vovk-metadata.json');
+const fetcher = require('${fetcherPath}');
+const streamFetcher = require('${streamFetcherPath}');
+const prefix = '${vovkrc.prefix ?? '/api'}';
+const validateOnClient = ${vovkrc.validateOnClient ? `require('${vovkrc.validateOnClient}')` : 'null'};
+
+`;
+  const metadataJson = await fs.readFile(path.join(__dirname, 'vovk-metadata.json'), 'utf-8');
+  const metadata = JSON.parse(metadataJson || '{}');
+
+  for (const key of Object.keys(metadata)) {
+    if (key !== 'workers') {
+      ts += `export type ${key} = ReturnType<typeof clientizeController<Controllers["${key}"], Options>>;\n`;
+      js += `exports.${key} = clientizeController(metadata.${key}, { fetcher, streamFetcher, validateOnClient, defaultOptions: { prefix } });\n`;
+    }
+  }
+
+  /* for(const key of Object.keys(metadata.workers ?? {})) {
+    code += `export const ${key} = promisifyWorker<${key}>(metadata.workers.${key});\n`;
+} */
+
+  await fs.writeFile(path.join(__dirname, '../../.vovk/index.d.ts'), ts);
+  await fs.writeFile(path.join(__dirname, '../../.vovk/index.js'), js);
+}
+
+module.exports = generateClient;

package/cli/getVovkrc.js

@@ -0,0 +1,28 @@
+const fs = require('fs');
+
+let vovkRcRef = null;
+
+function getVovkrc(rcPath) {
+  if (vovkRcRef) {
+    return vovkRcRef;
+  }
+
+  const vovkRc = {
+    route: 'src/app/api/[[...]]/route.ts',
+    fetcher: 'vovk/client/fetcher',
+    streamFetcher: 'vovk/client/streamFetcher',
+    prefix: '/api',
+    // validateOnClient: 'vovk-zod/validateOnClient',
+  };
+  if (fs.existsSync(rcPath)) {
+    Object.assign(vovkRc, require(rcPath));
+  } else {
+    console.info(` 🐺 No .vovkrc.js file found in ${process.cwd()}.`);
+  }
+
+  vovkRcRef = vovkRc;
+
+  return vovkRc;
+}
+
+module.exports = getVovkrc;

package/cli/index.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+const yargs = require('yargs/yargs');
+const { hideBin } = require('yargs/helpers');
+const { concurrently } = require('concurrently');
+const generateClient = require('./generateClient');
+const path = require('path');
+
+const builder = {
+  rc: {
+    type: 'string',
+    default: path.join(process.cwd(), '.vovkrc.js'),
+    describe: 'Path to .vovkrc.js',
+  },
+
+  project: {
+    type: 'string',
+    default: process.cwd(),
+    describe: 'Path to Next.js project',
+  },
+
+  output: {
+    type: 'string',
+    default: path.join(__dirname, '../.vovk/index.d.ts'),
+    describe: 'Path to the wildcard route file',
+  },
+};
+
+const options = {
+  outputStream: process.stdout,
+  raw: true,
+  killOthers: ['failure', 'success'],
+};
+/** @type {{ rc: string, project: string, output: string }} */
+const argv = yargs(hideBin(process.argv))
+  .command('dev', 'Run development server', builder)
+  .command('build', 'Build the app', builder)
+  .command('generate', 'Generate client', builder).argv;
+
+const nextArgs = process.argv.join(' ').split(' -- ')[1] ?? '';
+
+if (argv._.includes('dev')) {
+  const { result } = concurrently(
+    [
+      { command: `node ${__dirname}/server.js`, name: 'Vovk' },
+      { command: `node ${__dirname}/watchMetadata.js --rc ${argv.rc} --output ${argv.output}`, name: 'Watch metadata' },
+      { command: `cd ${argv.project} && npx next dev ${nextArgs}`, name: 'Next' },
+    ],
+    options
+  );
+
+  void result.then(() => {
+    console.info(' 🐺 All processes have completed.');
+  });
+}
+
+if (argv._.includes('build')) {
+  const { result } = concurrently(
+    [
+      { command: `node ${__dirname}/server.js --once`, name: 'Vovk' },
+      { command: `cd ${argv.project} && npx next build ${nextArgs}`, name: 'Next' },
+    ],
+    options
+  );
+
+  void result
+    .catch((e) => console.error(e))
+    .then(async () => {
+      await generateClient(argv.rc, argv.output);
+      console.info(' 🐺 Both processes have completed and the client is generated.');
+    });
+}
+
+if (argv._.includes('generate')) {
+  void generateClient(argv.rc, argv.output).then(() => {
+    console.info(' 🐺 Client generated.');
+  });
+}

package/cli/server.js

@@ -0,0 +1,76 @@
+const http = require('http');
+const fs = require('fs/promises');
+const path = require('path');
+const yargs = require('yargs/yargs');
+const { hideBin } = require('yargs/helpers');
+
+const argv = yargs(hideBin(process.argv)).argv;
+
+const once = argv.once ?? false;
+
+const 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;
+};
+
+const writeMetadata = async (metadataPath, metadata) => {
+  await fs.mkdir(path.dirname(metadataPath), { recursive: true });
+  const existingMetadata = await fs.readFile(metadataPath, 'utf-8').catch(() => '{}');
+  if (isEqual(JSON.parse(existingMetadata), metadata)) return;
+  await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+  console.info(' 🐺 JSON data received and metadata file created');
+};
+
+const server = http.createServer((req, res) => {
+  if (req.method === 'POST' && req.url === '/__metadata') {
+    let body = '';
+
+    req.on('data', (chunk) => {
+      body += chunk.toString(); // Convert Buffer to string
+    });
+
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    req.on('end', async () => {
+      try {
+        const metadata = JSON.parse(body); // Parse the JSON data
+        const filePath = path.join(__dirname, '../.vovk/vovk-metadata.json');
+        await writeMetadata(filePath, metadata);
+        res.writeHead(200, { 'Content-Type': 'text/plain' });
+        res.end('JSON data received and file created');
+      } catch (err) {
+        res.writeHead(400, { 'Content-Type': 'text/plain' });
+        res.end('Invalid JSON');
+        console.error(' ❌ ' + err.message);
+      }
+      if (once) server.close();
+    });
+  } else {
+    res.writeHead(404, { 'Content-Type': 'text/plain' });
+    res.end('Not Found');
+  }
+});
+
+const PORT = process.env.VOVK_PORT || 3420;
+server.listen(PORT, () => {
+  console.info(` 🐺 Vovk Server running on port ${PORT}`);
+});

package/cli/vovk-metadata.json

@@ -0,0 +1,178 @@
+{
+  "ClientController": {
+    "_controllerName": "ClientController",
+    "_prefix": "client",
+    "_handlers": {
+      "getWithParams": {
+        "path": "with-params/:hello",
+        "httpMethod": "GET"
+      },
+      "postWithParams": {
+        "path": "with-params/:hello",
+        "httpMethod": "POST"
+      },
+      "postWithEqualityValidation": {
+        "clientValidators": {
+          "body": {
+            "hello": "body"
+          },
+          "query": {
+            "hey": "query"
+          }
+        },
+        "path": "client-controller/post-with-equality-validation",
+        "httpMethod": "POST"
+      },
+      "postFormData": {
+        "clientValidators": {
+          "body": null,
+          "query": {
+            "type": "object",
+            "properties": {
+              "hello": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "hello"
+            ],
+            "additionalProperties": false,
+            "$schema": "http://json-schema.org/draft-07/schema#"
+          }
+        },
+        "path": "client-controller/post-form-data",
+        "httpMethod": "POST"
+      },
+      "postWithZodValidationAndEqualityValidation": {
+        "clientValidators": {
+          "body": {
+            "type": "object",
+            "properties": {
+              "hello": {
+                "type": "string",
+                "const": "body"
+              }
+            },
+            "required": [
+              "hello"
+            ],
+            "additionalProperties": false,
+            "$schema": "http://json-schema.org/draft-07/schema#"
+          },
+          "query": {
+            "type": "object",
+            "properties": {
+              "hey": {
+                "type": "string",
+                "const": "query"
+              }
+            },
+            "required": [
+              "hey"
+            ],
+            "additionalProperties": false,
+            "$schema": "http://json-schema.org/draft-07/schema#"
+          }
+        },
+        "path": "client-controller/post-with-zod-validation-and-equality-validation",
+        "httpMethod": "POST"
+      },
+      "getHelloWorld": {
+        "path": "client-controller/get-hello-world",
+        "httpMethod": "GET"
+      },
+      "getHelloWorldArray": {
+        "path": "client-controller/get-hello-world-array",
+        "httpMethod": "GET"
+      },
+      "getHelloWorldAndEmptyGeneric": {
+        "path": "client-controller/get-hello-world-and-empty-generic",
+        "httpMethod": "GET"
+      }
+    }
+  },
+  "StreamingController": {
+    "_controllerName": "StreamingController",
+    "_prefix": "streaming",
+    "_handlers": {
+      "postWithStreaming": {
+        "path": "streaming-controller/post-with-streaming",
+        "httpMethod": "POST"
+      },
+      "postWithStreamingAndImmediateError": {
+        "path": "streaming-controller/post-with-streaming-and-immediate-error",
+        "httpMethod": "POST"
+      },
+      "postWithStreamingAndDelayedError": {
+        "path": "streaming-controller/post-with-streaming-and-delayed-error",
+        "httpMethod": "POST"
+      },
+      "postWithStreamingAndDelayedCustomError": {
+        "path": "streaming-controller/post-with-streaming-and-delayed-custom-error",
+        "httpMethod": "POST"
+      },
+      "postWithStreamingAndDelayedUnhandledError": {
+        "path": "streaming-controller/post-with-streaming-and-delayed-unhandled-error",
+        "httpMethod": "POST"
+      }
+    }
+  },
+  "StreamingGeneratorController": {
+    "_controllerName": "StreamingGeneratorController",
+    "_prefix": "streaming-generator",
+    "_handlers": {
+      "postWithAsyncStreaming": {
+        "path": "streaming-generator-controller/post-with-async-streaming",
+        "httpMethod": "POST"
+      },
+      "postWithStreaming": {
+        "path": "streaming-generator-controller/post-with-streaming",
+        "httpMethod": "POST"
+      },
+      "postWithStreamingAndImmediateError": {
+        "path": "streaming-generator-controller/post-with-streaming-and-immediate-error",
+        "httpMethod": "POST"
+      },
+      "postWithStreamingAndDelayedError": {
+        "path": "streaming-generator-controller/post-with-streaming-and-delayed-error",
+        "httpMethod": "POST"
+      },
+      "postWithStreamingAndDelayedCustomError": {
+        "path": "streaming-generator-controller/post-with-streaming-and-delayed-custom-error",
+        "httpMethod": "POST"
+      },
+      "postWithStreamingAndDelayedUnhandledError": {
+        "path": "streaming-generator-controller/post-with-streaming-and-delayed-unhandled-error",
+        "httpMethod": "POST"
+      }
+    }
+  },
+  "workers": {
+    "MyWorker": {
+      "_workerName": "MyWorker",
+      "_handlers": {
+        "getHetClientizeHelloWorld": {},
+        "calculateFibonacci": {},
+        "findLargestPrimeBelow": {},
+        "asyncGenerator": {
+          "isGenerator": true
+        },
+        "asyncGeneratorWithError": {
+          "isGenerator": true
+        },
+        "generator": {
+          "isGenerator": true
+        },
+        "generatorWithError": {
+          "isGenerator": true
+        }
+      }
+    },
+    "MyInnerWorker": {
+      "_workerName": "MyInnerWorker",
+      "_handlers": {
+        "calculateFibonacci": {}
+      }
+    }
+  }
+}

package/cli/watchMetadata.js

@@ -0,0 +1,20 @@
+const { watch } = require('node:fs/promises');
+const path = require('path');
+const generateClient = require('./generateClient');
+
+const yargs = require('yargs/yargs');
+const { hideBin } = require('yargs/helpers');
+
+const argv = yargs(hideBin(process.argv)).argv;
+
+async function watchMetadata() {
+  const jsonWatcher = watch(path.join(__dirname, '../../.vovk/vovk-metadata.json'));
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  for await (const _event of jsonWatcher) {
+    await generateClient(argv.rc, argv.output);
+    console.info(' 🐺 Client generated');
+  }
+}
+
+void watchMetadata();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk",
-  "version": "0.2.3-beta.3",
+  "version": "0.2.3-beta.4",
   "description": "Structural add-on for Next.js",
   "bin": "./cli/index.js",
   "scripts": {
@@ -13,7 +13,7 @@
     "deploy-docs": "npm run --prefix docs deploy",
     "postpublish": "node ../post-publish-test/post-publish.js",
     "serve:unit": "npm --prefix test run build && npm --prefix test run start",
-    "build": "rm -rf dist && npm run toc && tsc && cp package.json dist && cp README.md dist && cp package-lock.json dist",
+    "build": "rm -rf dist && npm run toc && tsc && cp package.json dist && cp README.md dist && cp package-lock.json dist && cp -r cli dist",
     "lint-nofix": "eslint . --ext .ts,.tsx",
     "lint": "npm run lint-nofix -- --fix",
     "toc": "npx markdown-toc README.md -i",