How to test

0. Build project (on this project)

npm run build

build action will create codegen-nodejs-typeorm binary and accessible from terminal.

1. Create testing folder

mkdir naiv-test-server
cd naiv-test-server

2. Init Typescript Project

npm init -y
npm install --save-dev typescript

3. Modify package.json script

  "scripts": {
    "typeorm": "typeorm-ts-node-commonjs",
    "generate-migration": "npm run typeorm migration:generate -- $1 -d ./data-source.ts",
    "migrate": "npm run typeorm migration:run -- -d ./data-source.ts",
    "codegen": "codegen-nodejs-typeorm -d design -o types",
    "codegen-init": "npx ts-node ./generate-initial-api.ts",
    "build": "rm -rf dist && tsc",
    "start": "node dist",
    "dev": "npm run build && npm start"
  },

4. Create TS-Config file

{
  // Visit https://aka.ms/tsconfig to read more about this file
  "compilerOptions": {

    // Environment Settings
    // See also https://aka.ms/tsconfig/module
    "module": "nodenext",
    "target": "esnext",
    "types": ["node"],

    // Stricter Typechecking Options
    "noUncheckedIndexedAccess": true,
    "exactOptionalPropertyTypes": true,

    // Recommended Options
    "strict": true,
    "jsx": "react-jsx",
    "verbatimModuleSyntax": false,
    "isolatedModules": true,
    "noUncheckedSideEffectImports": true,
    "moduleDetection": "force",
    "skipLibCheck": true,
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "outDir": "dist"
  }
}

5. Install dependency

npm install --save express cors class-validator class-transformer
npm install --save-dev @types/express @types/cors

6. Create generate-initial-api.ts

import * as fs from 'fs';
import * as path from 'path';

function getAllTsFiles(dir: string): string[] {
  const files = fs.readdirSync(dir, { withFileTypes: true });
  const tsFiles: string[] = [];

  for (const file of files) {
    if (file.isFile() && file.name.endsWith('.ts')) {
      tsFiles.push(file.name);
      const filePath = path.resolve(`./implementation/${file.name}`);
      if (fs.existsSync(filePath)) {
        console.log(`✅ File already exists: ${filePath}`);
      } else {
        const [fn] = file.name.split('.');
        const prefix = fn?.slice(0, 2);
        const only_name = fn?.slice(2);
        const is_streaming = prefix == 'S_';
        fs.writeFileSync(filePath, `\
import { ${prefix}${only_name} } from "../types/api/${prefix}${only_name}";

export const ${prefix?.toLowerCase()}${only_name}: ${prefix}${only_name} = async ${is_streaming ? '(req, stream, res)' : '(req, res)'} => {
  throw new Error('Implement this');
}
`, 'utf8');
        console.log(`📝 File created: ${filePath}`);
      }
    }
  }

  return tsFiles;
}

console.log(getAllTsFiles('./types/api'));

7. Create simple api design design/api.naiv

schema Z {
  data string required
}

api get /test-streaming {
  alias testX
  query {
    q string
  }
  return stream of string required
}

api get /common-api {
  alias getY
  query {
    limit number
    offset number
  }
  return array string required
}

8. Generate code

npm run codegen

9. Generate code-stub

npm run codegen-init

10. Copy server.ts from this project to naiv-test-server project

11. Create index.ts

import path from 'path';
import { Server } from './server';

const server = new Server();
server.run({
  port: +(process.env.PORT ?? 9415),
  types_path: path.resolve(__dirname, 'types'),
  implementation_path: path.resolve(__dirname, 'implementation'),
  async beforeStart() {
    console.log('before start script.')
  }
});

12. Implement logic

import { S_testX } from "../types/api/S_testX";

export const s_testX: S_testX = async (req, stream, res) => {
  stream(req.query.q ?? 'no query');
  stream('\n');
  stream('aaa\n');
  await new Promise(resolve => setTimeout(resolve, 1000));
  stream('ccc\n');
  await new Promise(resolve => setTimeout(resolve, 1000));
  stream('bbb\n');
  await new Promise(resolve => setTimeout(resolve, 1000));
  stream('eee\n');
  await new Promise(resolve => setTimeout(resolve, 1000));
  stream('ddd\n');
  await new Promise(resolve => setTimeout(resolve, 1000));
  stream('fff\n');
  await new Promise(resolve => setTimeout(resolve, 1000));
}

import { T_getY } from "../types/api/T_getY";

export const t_getY: T_getY = async (req, res) => {
  return ['nice'];
}

13. curl testing

curl localhost:9415/test-streaming?q=lorem-ipsum -N

curl localhost:9415/common-api