apply.ts

importfsfrom"fs/promises";
import{OpenAPIV3_1}from"openapi-types";
importargvfrom"yargs-parser";

functionfindObjectFromRef<T>(obj: T|OpenAPIV3_1.ReferenceObject,openapi: OpenAPIV3_1.Document): T{
constref=(objasOpenAPIV3_1.ReferenceObject).$ref;
if(ref===undefined){
returnobjasT;
}
constparamParts=ref.split("/");
paramParts.shift();// Remove the first part which is always '#'

letfoundObj: Record<string,unknown>=openapi;
while(true){
constpart=paramParts.shift();
if(!part){
break;
}

foundObj=foundObj[part]asRecord<string,unknown>;
}
returnfoundObjasT;
}

asyncfunctionmain(){
const{ spec, file }=argv(process.argv.slice(2));

if(!spec||!file){
console.error("Please provide both --spec and --file arguments.");
process.exit(1);
}

constspecFile=awaitfs.readFile(specasstring,"utf8");

constoperations: {
path: string;
method: string;
operationId: string;
requiredParams: boolean;
tag: string;
hasResponseBody: boolean;
}[]=[];

constopenapi=JSON.parse(specFile)asOpenAPIV3_1.Document;
for(constpathinopenapi.paths){
for(constmethodinopenapi.paths[path]){
// @ts-expect-error This is a workaround for the OpenAPI types
constoperation=openapi.paths[path][method]asOpenAPIV3_1.OperationObject;

if(!operation.operationId||!operation.tags?.length){
continue;
}

letrequiredParams=!!operation.requestBody;
lethasResponseBody=false;
for(constcodeinoperation.responses){
try{
consthttpCode=parseInt(code,10);
if(httpCode>=200&&httpCode<300){
constresponse=operation.responses[code];
constresponseObject=findObjectFromRef(response,openapi);
if(responseObject.content){
for(constcontentTypeinresponseObject.content){
constcontent=responseObject.content[contentType];
hasResponseBody=!!content.schema;
}
}
}
}catch{
continue;
}
}

for(constparamofoperation.parameters||[]){
constparamObject=findObjectFromRef(param,openapi);
if(paramObject.in==="path"){
requiredParams=true;
}
}

operations.push({
 path,
method: method.toUpperCase(),
operationId: operation.operationId||"",
 requiredParams,
 hasResponseBody,
tag: operation.tags[0],
});
}
}

constoperationOutput=operations
.map((operation)=>{
const{ operationId, method, path, requiredParams, hasResponseBody }=operation;
return`async ${operationId}(options${requiredParams ? "" : "?"}: FetchOptions<operations["${operationId}"]>) {
${hasResponseBody ? `const { data } = ` : ``}await this.client.${method}("${path}", options);
${
hasResponseBody
 ? `return data;
`
 : ``
}}
`;
})
.join("\n");

consttemplateFile=awaitfs.readFile(fileasstring,"utf8");
consttemplateLines=templateFile.split("\n");
constoutputLines: string[]=[];
letaddLines=true;
for(constlineoftemplateLines){
if(line.includes("DO NOT EDIT. This is auto-generated code.")){
addLines=!addLines;
outputLines.push(line);
if(!addLines){
outputLines.push(operationOutput);
}
continue;
}
if(addLines){
outputLines.push(line);
}
}
constoutput=outputLines.join("\n");

awaitfs.writeFile(fileasstring,output,"utf8");
}

main().catch((error)=>{
console.error("Error:",error);
process.exit(1);
});