generate-api-types.js

import 'dotenv/config';
import fs from 'fs';
import path from 'path';
import { generateApi } from 'swagger-typescript-api';
import { parse as $RefParser } from '@apidevtools/json-schema-ref-parser';

const backendUrl = process.env.VITE_SERVER_URL;
const swaggerUrl = backendUrl + '/docs.json';
const outputDir = path.resolve(process.cwd(), 'src/api/types');

function getAllSchemaRefs(obj, refs = new Set()) {
  if (typeof obj !== 'object' || obj === null) return refs;

  if (Array.isArray(obj)) {
    for (const item of obj) {
      getAllSchemaRefs(item, refs);
    }
    return refs;
  }

  for (const key in obj) {
    const value = obj[key];
    if (
      key === '$ref' &&
      typeof value === 'string' &&
      value.startsWith('#/components/schemas/')
    ) {
      const refName = value.split('/').pop();
      if (refName && !refs.has(refName)) {
        refs.add(refName);
      }
    } else {
      getAllSchemaRefs(value, refs);
    }
  }

  return refs;
}

function removeSwaggerHeader(filePath) {
  if (!fs.existsSync(filePath)) return;

  let content = fs.readFileSync(filePath, 'utf8');
  content = content.replace(
    /\/\*[\s\S]*?## SOURCE: https:\/\/github\.com\/acacode\/swagger-typescript-api ##[\s\S]*?\*\/\s*/,
    ''
  );
  fs.writeFileSync(filePath, content);
}

function extractVersionFromPath(pathKey) {
  const versionMatch = pathKey.match(/^\/(v[0-9]+)/i);
  return versionMatch?.[1] ?? 'unversioned';
}

function buildTagVersionMap(rawSpec) {
  const tagMap = new Map();

  Object.entries(rawSpec.paths).forEach(([pathKey, methods]) => {
    const pathVersion = extractVersionFromPath(pathKey);

    Object.values(methods)
      .filter((method) => method?.tags)
      .forEach((method) => {
        method.tags.forEach((tag) => {
          if (!tagMap.has(tag)) tagMap.set(tag, new Set());
          tagMap.get(tag).add(pathVersion);
        });
      });
  });

  return tagMap;
}

function filterSpecByTagAndVersion(spec, tag, version) {
  const filteredSpec = JSON.parse(JSON.stringify(spec));

  Object.entries(filteredSpec.paths).forEach(([pathKey, methods]) => {
    const pathVersion = extractVersionFromPath(pathKey);

    if (pathVersion !== version) {
      delete filteredSpec.paths[pathKey];
      return;
    }

    const filteredMethods = Object.fromEntries(
      Object.entries(methods).filter(([, method]) =>
        method?.tags?.includes(tag)
      )
    );

    if (Object.keys(filteredMethods).length === 0) {
      delete filteredSpec.paths[pathKey];
    } else {
      filteredSpec.paths[pathKey] = filteredMethods;
    }
  });

  return filteredSpec;
}

function filterSchemas(spec) {
  const allSchemas = spec.components?.schemas || {};
  const allUsedSchemas = new Set();
  function collectAllRefs(schemaName) {
    if (!schemaName || allUsedSchemas.has(schemaName)) return;
    allUsedSchemas.add(schemaName);
    const schema = allSchemas[schemaName];
    if (!schema) return;
    const refs = getAllSchemaRefs(schema);
    for (const ref of refs) {
      collectAllRefs(ref);
    }
  }
  const directRefs = getAllSchemaRefs(spec.paths);
  for (const schemaName of directRefs) {
    collectAllRefs(schemaName);
  }
  const filteredSchemas = Object.fromEntries(
    Object.entries(allSchemas).filter(([schemaName]) =>
      allUsedSchemas.has(schemaName)
    )
  );
  return {
    ...spec,
    components: {
      ...spec.components,
      schemas: filteredSchemas,
    },
  };
}

function ensureDirectoryExists(dirPath) {
  if (!fs.existsSync(dirPath)) {
    fs.mkdirSync(dirPath, { recursive: true });
  }
}

function cleanOutputDirectory() {
  if (fs.existsSync(outputDir)) {
    fs.rmSync(outputDir, { recursive: true, force: true });
  }
}

async function generateTypeFile(spec, tag, version, versionDir) {
  const tagFileName = `${tag.toLowerCase()}.type.ts`;
  const tagFilePath = path.join(versionDir, tagFileName);

  await generateApi({
    name: tagFileName,
    output: versionDir,
    httpClientType: 'fetch',
    spec,
    modular: false,
    generateClient: false,
    cleanOutput: false,
  });

  const possiblePaths = [
    path.join(versionDir, 'index.ts'),
    path.join(versionDir, 'Api.ts'),
  ];

  for (const possiblePath of possiblePaths) {
    if (fs.existsSync(possiblePath)) {
      if (fs.existsSync(tagFilePath)) fs.unlinkSync(tagFilePath);
      fs.renameSync(possiblePath, tagFilePath);
      break;
    }
  }

  removeSwaggerHeader(tagFilePath);
  return `[GENERATED]: ${version}/${tagFileName}`;
}

async function fetchSpecs() {
  const dereferencedSpec = await $RefParser(swaggerUrl);
  return { dereferencedSpec };
}

async function main() {
  try {
    if (!backendUrl) throw new Error('[ENV ERROR]:VITE_SERVER_URL not defined');

    cleanOutputDirectory();

    const { dereferencedSpec } = await fetchSpecs();
    const tagMap = buildTagVersionMap(dereferencedSpec);

    const generatedFiles = [];

    for (const [tag, versions] of tagMap.entries()) {
      const versionFiles = await Promise.all(
        Array.from(versions).map(async (version) => {
          const versionDir = path.join(outputDir, version);
          ensureDirectoryExists(versionDir);

          let filteredSpec = filterSpecByTagAndVersion(
            dereferencedSpec,
            tag,
            version
          );
          filteredSpec = filterSchemas(filteredSpec);

          return await generateTypeFile(filteredSpec, tag, version, versionDir);
        })
      );

      generatedFiles.push(...versionFiles);
    }

    console.log(generatedFiles.join('\n'));
  } catch (error) {
    console.error('[ERROR]', error);
    process.exit(1);
  }
}

main();